home *** CD-ROM | disk | FTP | other *** search
/ InterCD 2000 September / september_2000.iso / intercd / root / ^Linux / WindowMaker / src / menu.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-04-02  |  68.5 KB  |  2,760 lines
  1. /* menu.c- generic menu, used for root menu, application menus etc.
  2.  *
  3.  *  Window Maker window manager
  4.  * 
  5.  *  Copyright (c) 1997, 1998 Alfredo K. Kojima
  6.  *  Copyright (c) 1997, 1998 Dan Pascu
  7.  * 
  8.  *  This program is free software; you can redistribute it and/or modify
  9.  *  it under the terms of the GNU General Public License as published by
  10.  *  the Free Software Foundation; either version 2 of the License, or
  11.  *  (at your option) any later version.
  12.  *
  13.  *  This program is distributed in the hope that it will be useful,
  14.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16.  *  GNU General Public License for more details.
  17.  *
  18.  *  You should have received a copy of the GNU General Public License
  19.  *  along with this program; if not, write to the Free Software
  20.  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 
  21.  *  USA.
  22.  */
  23.  
  24. #include "wconfig.h"
  25.  
  26. #include <X11/Xlib.h>
  27. #include <X11/Xutil.h>
  28. #include <X11/keysym.h>
  29. #include <stdlib.h>
  30. #include <string.h>
  31. #include <stdio.h>
  32. #include <unistd.h>
  33. #include <ctype.h>
  34. #include <nana.h>
  35.  
  36. #include "WindowMaker.h"
  37. #include "wcore.h"
  38. #include "framewin.h"
  39. #include "menu.h"
  40. #include "actions.h"
  41. #include "funcs.h"
  42. #include "stacking.h"
  43. #include "text.h"
  44.  
  45.  
  46. /****** Global Variables ******/
  47.  
  48. extern Cursor wCursor[WCUR_LAST];
  49.  
  50. extern XContext wWinContext;
  51.  
  52. extern WPreferences wPreferences;
  53.  
  54. #define MOD_MASK wPreferences.modifier_mask
  55.  
  56. #define MENU_SCROLL_STEP  menuScrollParameters[(int)wPreferences.menu_scroll_speed].steps
  57. #define MENU_SCROLL_DELAY menuScrollParameters[(int)wPreferences.menu_scroll_speed].delay
  58.  
  59.  
  60.  
  61. #define MENUW(m)    ((m)->frame->core->width+2*FRAME_BORDER_WIDTH)
  62. #define MENUH(m)    ((m)->frame->core->height+2*FRAME_BORDER_WIDTH)
  63.  
  64.  
  65. /***** Local Stuff ******/
  66.  
  67. static struct {
  68.     int steps;
  69.     int delay;
  70. } menuScrollParameters[5] = {
  71.     {MENU_SCROLL_STEPS_UF, MENU_SCROLL_DELAY_UF},
  72.     {MENU_SCROLL_STEPS_F, MENU_SCROLL_DELAY_F},
  73.     {MENU_SCROLL_STEPS_M, MENU_SCROLL_DELAY_M},
  74.     {MENU_SCROLL_STEPS_S, MENU_SCROLL_DELAY_S},
  75.     {MENU_SCROLL_STEPS_U, MENU_SCROLL_DELAY_U}};
  76.  
  77.  
  78. static void menuMouseDown(WObjDescriptor *desc, XEvent *event);
  79. static void menuExpose(WObjDescriptor *desc, XEvent *event);
  80.  
  81. static void menuTitleDoubleClick(WCoreWindow *sender, void *data, XEvent *event);
  82. static void menuTitleMouseDown(WCoreWindow *sender, void *data, XEvent *event);
  83.  
  84. static void menuCloseClick(WCoreWindow *sender, void *data, XEvent *event);
  85.  
  86. static void updateTexture(WMenu *menu);
  87.  
  88. #ifndef LITE
  89. static int saveMenuRecurs(proplist_t menus, WScreen *scr, WMenu *menu);
  90. static int restoreMenuRecurs(WScreen *scr, proplist_t menus, WMenu *menu, char *path);
  91. #endif /* !LITE */
  92.  
  93. static void selectEntry(WMenu *menu, int entry_no);
  94. static void closeCascade(WMenu *menu);
  95.  
  96.  
  97. /****** Notification Observers ******/
  98.  
  99. static void
  100. appearanceObserver(void *self, WMNotification *notif)
  101. {
  102.     WMenu *menu = (WMenu*)self;
  103.     int flags = (int)WMGetNotificationClientData(notif);
  104.  
  105.     if (!menu->flags.realized)
  106.     return;
  107.     
  108.     if (WMGetNotificationName(notif) == WNMenuAppearanceSettingsChanged) {
  109.     if (flags & WFontSettings) {
  110.         menu->flags.realized = 0;
  111.         wMenuRealize(menu);
  112.     }
  113.     if (flags & WTextureSettings) {
  114.         if (!menu->flags.brother)
  115.         updateTexture(menu);
  116.     }
  117.     if (flags & (WTextureSettings|WColorSettings)) {
  118.         wMenuPaint(menu);
  119.     }
  120.     } else if (menu->flags.titled) {
  121.  
  122.     if (flags & WFontSettings) {
  123.         menu->flags.realized = 0;
  124.         wMenuRealize(menu);
  125.     }
  126.     if (flags & WTextureSettings) {
  127.         menu->frame->flags.need_texture_remake = 1;
  128.     }
  129.     if (flags & (WColorSettings|WTextureSettings)) {
  130.         wFrameWindowPaint(menu->frame);
  131.     }
  132.     }
  133. }
  134.  
  135. /************************************/
  136.  
  137.  
  138. /*
  139.  *----------------------------------------------------------------------
  140.  * wMenuCreate--
  141.  *     Creates a new empty menu with the specified title. If main_menu
  142.  * is True, the created menu will be a main menu, which has some special
  143.  * properties such as being placed over other normal menus.
  144.  *     If title is NULL, the menu will have no titlebar.
  145.  * 
  146.  * Returns:
  147.  *     The created menu.
  148.  *---------------------------------------------------------------------- 
  149.  */
  150. WMenu*
  151. wMenuCreate(WScreen *screen, char *title, int main_menu)
  152. {
  153.     WMenu *menu;
  154.     static int brother=0;
  155.     int tmp, flags;
  156.     
  157.     menu = wmalloc(sizeof(WMenu));
  158.  
  159.     memset(menu, 0, sizeof(WMenu));
  160.  
  161. #ifdef SINGLE_MENULEVEL
  162.     tmp = WMSubmenuLevel;
  163. #else
  164.     tmp = (main_menu ? WMMainMenuLevel : WMSubmenuLevel);
  165. #endif
  166.  
  167.     flags = WFF_SINGLE_STATE|WFF_BORDER;
  168.     if (title) {
  169.     flags |= WFF_TITLEBAR|WFF_RIGHT_BUTTON;
  170.     menu->flags.titled = 1;
  171.     }
  172.     menu->frame =
  173.     wFrameWindowCreate(screen, tmp, 8, 2, 1, 1, &wPreferences.menu_title_clearance, flags,
  174.                screen->menu_title_texture, NULL,
  175.                            screen->menu_title_pixel,
  176. #ifdef DRAWSTRING_PLUGIN
  177.                W_STRING_MTITLE,
  178. #endif
  179.                &screen->menu_title_gc,
  180.                            &screen->menu_title_font);
  181.                
  182.     menu->frame->core->descriptor.parent = menu;
  183.     menu->frame->core->descriptor.parent_type = WCLASS_MENU;
  184.     menu->frame->core->descriptor.handle_mousedown = menuMouseDown;
  185.     
  186.     wFrameWindowHideButton(menu->frame, WFF_RIGHT_BUTTON);
  187.  
  188.     if (title) {
  189.     menu->frame->title = wstrdup(title);
  190.     }
  191.  
  192.     menu->frame->flags.justification = WTJ_LEFT;
  193.  
  194.     menu->frame->rbutton_image = screen->b_pixmaps[WBUT_CLOSE];
  195.  
  196.     menu->entry_no = 0;
  197.     menu->alloced_entries = 0;
  198.     menu->selected_entry = -1;
  199.     menu->entries = NULL;
  200.     
  201.     menu->frame_x = screen->app_menu_x;
  202.     menu->frame_y = screen->app_menu_y;
  203.     
  204.     menu->frame->child = menu;
  205.  
  206.     menu->flags.lowered = 0;
  207.  
  208.     /* create borders */
  209.     if (title) {
  210.     /* setup object descriptors */
  211.     menu->frame->on_mousedown_titlebar = menuTitleMouseDown;
  212.     menu->frame->on_dblclick_titlebar = menuTitleDoubleClick;
  213.     }
  214.     
  215.     menu->frame->on_click_right = menuCloseClick;
  216.     
  217.     
  218.     menu->menu = wCoreCreate(menu->frame->core, 0, menu->frame->top_width,
  219.                  menu->frame->core->width, 10);
  220.  
  221.     menu->menu->descriptor.parent = menu;
  222.     menu->menu->descriptor.parent_type = WCLASS_MENU;
  223.     menu->menu->descriptor.handle_expose = menuExpose;
  224.     menu->menu->descriptor.handle_mousedown = menuMouseDown;
  225.     
  226.     menu->menu_texture_data = None;
  227.  
  228.     XMapWindow(dpy, menu->menu->window);
  229.  
  230.     XFlush(dpy);
  231.     
  232.     if (!brother) {
  233.     brother = 1;
  234.     menu->brother = wMenuCreate(screen, title, main_menu);
  235.     brother = 0;
  236.     menu->brother->flags.brother = 1;
  237.     menu->brother->brother = menu;
  238.     }
  239.     WMAddNotificationObserver(appearanceObserver, menu,
  240.                   WNMenuAppearanceSettingsChanged, menu);
  241.  
  242.     WMAddNotificationObserver(appearanceObserver, menu,
  243.                   WNMenuTitleAppearanceSettingsChanged, menu);
  244.  
  245.  
  246.     return menu;
  247. }
  248.  
  249.  
  250.  
  251.  
  252. WMenu*
  253. wMenuCreateForApp(WScreen *screen, char *title, int main_menu)
  254. {
  255.     WMenu *menu;
  256.     
  257.     menu = wMenuCreate(screen, title, main_menu);
  258.     if (!menu)
  259.       return NULL;
  260.     menu->flags.app_menu = 1;
  261.     menu->brother->flags.app_menu = 1;
  262.  
  263.     return menu;
  264. }
  265.  
  266.  
  267.  
  268. static void
  269. insertEntry(WMenu *menu, WMenuEntry *entry, int index)
  270. {
  271.     int i;
  272.     
  273.     for (i = menu->entry_no-1; i >= index; i--) {
  274.     menu->entries[i]->order++;
  275.     menu->entries[i+1] = menu->entries[i];
  276.     }
  277.     menu->entries[index] = entry;
  278. }
  279.  
  280.  
  281. WMenuEntry*
  282. wMenuInsertCallback(WMenu *menu, int index, char *text,
  283.             void (*callback)(WMenu *menu, WMenuEntry *entry), 
  284.             void *clientdata)
  285. {
  286.     WMenuEntry *entry;
  287.  
  288.     menu->flags.realized = 0;
  289.     menu->brother->flags.realized = 0;
  290.     
  291.     /* reallocate array if it's too small */
  292.     if (menu->entry_no >= menu->alloced_entries) {
  293.     void *tmp;
  294.  
  295.     tmp = wrealloc(menu->entries,
  296.                sizeof(WMenuEntry)*(menu->alloced_entries+5));
  297.  
  298.     menu->entries = tmp;
  299.     menu->alloced_entries += 5;
  300.     
  301.     menu->brother->entries = tmp;
  302.     menu->brother->alloced_entries = menu->alloced_entries;
  303.     }
  304.     entry = wmalloc(sizeof(WMenuEntry));
  305.     memset(entry, 0, sizeof(WMenuEntry));
  306.     entry->flags.enabled = 1;
  307.     entry->text = wstrdup(text);
  308.     entry->cascade = -1;
  309.     entry->clientdata = clientdata;
  310.     entry->callback = callback;
  311.     if (index<0 || index>=menu->entry_no) {
  312.     entry->order = menu->entry_no;
  313.     menu->entries[menu->entry_no] = entry;
  314.     } else {
  315.     entry->order = index;
  316.     insertEntry(menu, entry, index);
  317.     }
  318.     
  319.     menu->entry_no++;
  320.     menu->brother->entry_no = menu->entry_no;
  321.     
  322.     return entry;
  323. }
  324.  
  325.  
  326.  
  327. void
  328. wMenuEntrySetCascade(WMenu *menu, WMenuEntry *entry, WMenu *cascade)
  329. {
  330.     WMenu *brother = menu->brother;
  331.     int i, done;
  332.  
  333.     assert(menu->flags.brother==0);
  334.     
  335.     if (entry->cascade>=0) {
  336.     menu->flags.realized = 0;
  337.     brother->flags.realized = 0;
  338.     }
  339.     
  340.     cascade->parent = menu;
  341.  
  342.     cascade->brother->parent = brother;
  343.  
  344.     done = 0;
  345.     for (i=0; i<menu->cascade_no; i++) {
  346.     if (menu->cascades[i]==NULL) {
  347.         menu->cascades[i] = cascade;
  348.         brother->cascades[i] = cascade->brother;
  349.         done = 1;
  350.         entry->cascade = i;
  351.         break;
  352.     }
  353.     }
  354.     if (!done) {
  355.     entry->cascade = menu->cascade_no;
  356.  
  357.     menu->cascades = wrealloc(menu->cascades, 
  358.                   sizeof(WMenu)*(menu->cascade_no+1));
  359.     menu->cascades[menu->cascade_no++] = cascade;
  360.     
  361.  
  362.     brother->cascades = wrealloc(brother->cascades, 
  363.                      sizeof(WMenu)*(brother->cascade_no+1));
  364.     brother->cascades[brother->cascade_no++] = cascade->brother;
  365.     }
  366.  
  367.  
  368.     if (menu->flags.lowered) {
  369.     
  370.     cascade->flags.lowered = 1;
  371.     ChangeStackingLevel(cascade->frame->core, WMNormalLevel);
  372.     
  373.     cascade->brother->flags.lowered = 1;
  374.     ChangeStackingLevel(cascade->brother->frame->core, WMNormalLevel);
  375.     }
  376.     
  377.     if (!menu->flags.realized)
  378.     wMenuRealize(menu);
  379. }
  380.  
  381.  
  382. void
  383. wMenuEntryRemoveCascade(WMenu *menu, WMenuEntry *entry)
  384. {    
  385.     assert(menu->flags.brother==0);
  386.     
  387.     /* destroy cascade menu */
  388.     if (entry->cascade>=0 && menu->cascades
  389.     && menu->cascades[entry->cascade]!=NULL) {
  390.  
  391.     wMenuDestroy(menu->cascades[entry->cascade], True);
  392.  
  393.     menu->cascades[entry->cascade] = NULL;
  394.     menu->brother->cascades[entry->cascade] = NULL;
  395.  
  396.     entry->cascade = -1;
  397.     }
  398. }
  399.  
  400.  
  401. void
  402. wMenuRemoveItem(WMenu *menu, int index)
  403. {
  404.     int i;
  405.     
  406.     if (menu->flags.brother) {
  407.     wMenuRemoveItem(menu->brother, index);
  408.     return;
  409.     }
  410.     
  411.     if (index>=menu->entry_no) return;
  412.  
  413.     /* destroy cascade menu */
  414.     wMenuEntryRemoveCascade(menu, menu->entries[index]);
  415.     
  416.     /* destroy unshared data */
  417.  
  418.     if (menu->entries[index]->text)
  419.       free(menu->entries[index]->text);
  420.     
  421.     if (menu->entries[index]->rtext)
  422.       free(menu->entries[index]->rtext);
  423.     
  424.     if (menu->entries[index]->free_cdata && menu->entries[index]->clientdata)
  425.       (*menu->entries[index]->free_cdata)(menu->entries[index]->clientdata);
  426.  
  427.     free(menu->entries[index]);
  428.     
  429.     for (i=index; i<menu->entry_no-1; i++) {
  430.     menu->entries[i+1]->order--;
  431.     menu->entries[i]=menu->entries[i+1];
  432.     }
  433.     menu->entry_no--;
  434.     menu->brother->entry_no--;
  435. }
  436.  
  437.  
  438. static Pixmap
  439. renderTexture(WMenu *menu)
  440. {
  441.     RImage *img;
  442.     Pixmap pix;
  443.     int i;
  444.     RColor light;
  445.     RColor dark;
  446.     RColor mid;
  447.     WScreen *scr = menu->menu->screen_ptr;
  448.     WTexture *texture = scr->menu_item_texture;
  449.  
  450.     if (wPreferences.menu_style == MS_NORMAL) {
  451.     img = wTextureRenderImage(texture, menu->menu->width, 
  452.                   menu->entry_height, WREL_MENUENTRY);
  453.     } else {
  454.     img = wTextureRenderImage(texture, menu->menu->width, 
  455.                   menu->menu->height+1, WREL_MENUENTRY);
  456.     }
  457.     if (!img) {
  458.     wwarning(_("could not render texture: %s"), 
  459.          RMessageForError(RErrorCode));
  460.  
  461.     return None;
  462.     }
  463.  
  464.     if (wPreferences.menu_style == MS_SINGLE_TEXTURE) {
  465.     light.alpha = 0;
  466.     light.red = light.green = light.blue = 80;
  467.     
  468.     dark.alpha = 255;
  469.     dark.red = dark.green = dark.blue = 0;
  470.     
  471.     mid.alpha = 0;
  472.     mid.red = mid.green = mid.blue = 40;
  473.     
  474.     for (i = 1; i < menu->entry_no; i++) {        
  475.         ROperateLine(img, RSubtractOperation, 0, i*menu->entry_height-2,
  476.              menu->menu->width-1, i*menu->entry_height-2, &mid);
  477.         
  478.         RDrawLine(img, 0, i*menu->entry_height-1,
  479.               menu->menu->width-1, i*menu->entry_height-1, &dark);
  480.  
  481.         ROperateLine(img, RAddOperation, 0, i*menu->entry_height,
  482.              menu->menu->width-1, i*menu->entry_height, 
  483.              &light);
  484.     }
  485.     }
  486.     if (!RConvertImage(scr->rcontext, img, &pix)) {
  487.     wwarning(_("error rendering image:%s"), RMessageForError(RErrorCode));
  488.     }
  489.     RDestroyImage(img);
  490.  
  491.     return pix;
  492. }
  493.  
  494.  
  495. static void
  496. updateTexture(WMenu *menu)
  497. {
  498.     WScreen *scr = menu->menu->screen_ptr;
  499.  
  500.     /* setup background texture */
  501.     if (scr->menu_item_texture->any.type != WTEX_SOLID) {
  502.     if (!menu->flags.brother) {
  503.         FREE_PIXMAP(menu->menu_texture_data);
  504.  
  505.         menu->menu_texture_data = renderTexture(menu);
  506.  
  507.         XSetWindowBackgroundPixmap(dpy, menu->menu->window,
  508.                        menu->menu_texture_data);
  509.         XClearWindow(dpy, menu->menu->window);
  510.  
  511.         XSetWindowBackgroundPixmap(dpy, menu->brother->menu->window,
  512.                        menu->menu_texture_data);
  513.         XClearWindow(dpy, menu->brother->menu->window);
  514.     }
  515.     } else {
  516.     XSetWindowBackground(dpy, menu->menu->window,
  517.                  scr->menu_item_texture->any.color.pixel);
  518.     XClearWindow(dpy, menu->menu->window);
  519.     }
  520. }
  521.  
  522.  
  523. void 
  524. wMenuRealize(WMenu *menu)
  525. {
  526.     int i;
  527.     int width, rwidth, mrwidth, mwidth;
  528.     int theight, twidth, eheight;
  529.     WScreen *scr = menu->frame->screen_ptr;
  530.     static int brother_done=0;
  531.     int flags;
  532.  
  533.     if (!brother_done) {
  534.     brother_done = 1;
  535.     wMenuRealize(menu->brother);
  536.     brother_done = 0;
  537.     }
  538.  
  539.     flags = WFF_SINGLE_STATE|WFF_BORDER;
  540.     if (menu->flags.titled)
  541.     flags |= WFF_TITLEBAR|WFF_RIGHT_BUTTON;
  542.  
  543.     wFrameWindowUpdateBorders(menu->frame, flags);
  544.  
  545.     if (menu->flags.titled) {
  546.     twidth = WMWidthOfString(scr->menu_title_font, menu->frame->title,
  547.                  strlen(menu->frame->title));
  548.         theight = menu->frame->top_width;
  549.         twidth += theight + (wPreferences.new_style ? 16 : 8);
  550.     } else {
  551.     twidth = 0;
  552.     theight = 0;
  553.     }
  554.     eheight = WMFontHeight(scr->menu_entry_font) + 6 + wPreferences.menu_text_clearance * 2;
  555.     menu->entry_height = eheight;
  556.     mrwidth = 0;
  557.     mwidth = 0;
  558.     for (i=0; i<menu->entry_no; i++) {
  559.     char *text;
  560.  
  561.     /* search widest text */
  562.     text = menu->entries[i]->text;
  563.     width = WMWidthOfString(scr->menu_entry_font, text, strlen(text))+10;
  564.  
  565.     if (menu->entries[i]->flags.indicator) {
  566.         width += MENU_INDICATOR_SPACE;
  567.     }
  568.  
  569.     if (width > mwidth)
  570.         mwidth = width;
  571.     
  572.     /* search widest text on right */
  573.     text = menu->entries[i]->rtext;
  574.     if (text)
  575.         rwidth = WMWidthOfString(scr->menu_entry_font, text, strlen(text))
  576.         + 5;
  577.     else if (menu->entries[i]->cascade>=0)
  578.         rwidth = 16;
  579.     else
  580.         rwidth = 4;
  581.  
  582.     if (rwidth > mrwidth)
  583.         mrwidth = rwidth;
  584.     }
  585.     mwidth += mrwidth;
  586.     
  587.     if (mwidth < twidth)
  588.     mwidth = twidth;
  589.  
  590.     
  591.     wCoreConfigure(menu->menu, 0, theight, mwidth, menu->entry_no*eheight -1);
  592.  
  593.     wFrameWindowResize(menu->frame, mwidth, menu->entry_no*eheight-1
  594.                + menu->frame->top_width + menu->frame->bottom_width);
  595.  
  596.  
  597.     updateTexture(menu);
  598.  
  599.     menu->flags.realized = 1;
  600.  
  601.     if (menu->flags.mapped)
  602.     wMenuPaint(menu);
  603.     if (menu->brother->flags.mapped)
  604.     wMenuPaint(menu->brother);
  605. }
  606.  
  607.  
  608. void
  609. wMenuDestroy(WMenu *menu, int recurse)
  610. {
  611.     int i;
  612.  
  613.     WMRemoveNotificationObserver(menu);
  614.     
  615.     /* remove any pending timers */
  616.     if (menu->timer)
  617.     WMDeleteTimerHandler(menu->timer);
  618.     menu->timer = NULL;
  619.     
  620.     /* call destroy handler */
  621.     if (menu->on_destroy)
  622.     (*menu->on_destroy)(menu);
  623.     
  624.     /* Destroy items if this menu own them. If this is the "brother" menu,
  625.      * leave them alone as it is shared by them.
  626.      */
  627.     if (!menu->flags.brother) {
  628.     for (i=0; i<menu->entry_no; i++) {
  629.  
  630.         free(menu->entries[i]->text);
  631.  
  632.         if (menu->entries[i]->rtext)
  633.           free(menu->entries[i]->rtext);
  634. #ifdef USER_MENU
  635.  
  636.         if (menu->entries[i]->instances){
  637.           PLRelease(menu->entries[i]->instances);
  638.         }
  639. #endif /* USER_MENU */
  640.  
  641.         if (menu->entries[i]->free_cdata && menu->entries[i]->clientdata) {
  642.         (*menu->entries[i]->free_cdata)(menu->entries[i]->clientdata);
  643.         }
  644.         free(menu->entries[i]);
  645.     }
  646.  
  647.     if (recurse) {
  648.         for (i=0; i<menu->cascade_no; i++) {
  649.         if (menu->cascades[i]) {
  650.             if (menu->cascades[i]->flags.brother)
  651.               wMenuDestroy(menu->cascades[i]->brother, recurse);
  652.             else
  653.               wMenuDestroy(menu->cascades[i], recurse);
  654.         }
  655.         }
  656.     }
  657.     
  658.     if (menu->entries)
  659.         free(menu->entries);
  660.     
  661.     }
  662.  
  663.     FREE_PIXMAP(menu->menu_texture_data);
  664.     
  665.     if (menu->cascades)
  666.       free(menu->cascades);
  667.  
  668.     wCoreDestroy(menu->menu);
  669.     wFrameWindowDestroy(menu->frame);
  670.     
  671.     /* destroy copy of this menu */
  672.     if (!menu->flags.brother && menu->brother)
  673.     wMenuDestroy(menu->brother, False);
  674.     
  675.     free(menu);
  676. }
  677.  
  678.  
  679. #define F_NORMAL    0
  680. #define F_TOP        1
  681. #define F_BOTTOM    2
  682. #define F_NONE        3
  683.  
  684. static void
  685. drawFrame(WScreen *scr, Window win, int y, int w, int h, int type)
  686. {
  687.     XSegment segs[2];
  688.     int i;
  689.  
  690.     i = 0;
  691.     segs[i].x1 = segs[i].x2 = w-1;
  692.     segs[i].y1 = y;
  693.     segs[i].y2 = y + h - 1;
  694.     i++;
  695.     if (type != F_TOP && type != F_NONE) {
  696.     segs[i].x1 = 1;
  697.     segs[i].y1 = segs[i].y2 = y + h-2;
  698.     segs[i].x2 = w-1;
  699.     i++;
  700.     }
  701.     XDrawSegments(dpy, win, scr->menu_item_auxtexture->dim_gc, segs, i);
  702.  
  703.     i = 0;
  704.     segs[i].x1 = 0;
  705.     segs[i].y1 = y;
  706.     segs[i].x2 = 0;
  707.     segs[i].y2 = y + h - 1;
  708.     i++;
  709.     if (type != F_BOTTOM && type != F_NONE) {
  710.     segs[i].x1 = 0;
  711.     segs[i].y1 = y;
  712.     segs[i].x2 = w-1;
  713.     segs[i].y2 = y;
  714.     i++;
  715.     }
  716.     XDrawSegments(dpy, win, scr->menu_item_auxtexture->light_gc, segs, i);
  717.  
  718.     if (type != F_TOP && type != F_NONE)
  719.     XDrawLine(dpy, win, scr->menu_item_auxtexture->dark_gc, 0, y+h-1,
  720.           w-1, y+h-1);
  721. }
  722.  
  723.  
  724. static void
  725. paintEntry(WMenu *menu, int index, int selected)
  726. {
  727.     int x, y, w, h, tw;
  728.     int type;
  729.     GC light, dim, dark, textGC;
  730.     WScreen *scr=menu->frame->screen_ptr;
  731.     Window win = menu->menu->window;
  732.     WMenuEntry *entry=menu->entries[index];
  733.  
  734.     if (!menu->flags.realized) return;
  735.     h = menu->entry_height;
  736.     w = menu->menu->width;
  737.     y = index * h;
  738.  
  739.     light = scr->menu_item_auxtexture->light_gc;
  740.     dim = scr->menu_item_auxtexture->dim_gc;
  741.     dark = scr->menu_item_auxtexture->dark_gc;
  742.  
  743.     if (wPreferences.menu_style == MS_FLAT && menu->entry_no > 1) {
  744.     if (index == 0)
  745.         type = F_TOP;
  746.     else if (index == menu->entry_no - 1)
  747.         type = F_BOTTOM;
  748.     else
  749.         type = F_NONE;
  750.     } else {
  751.     type = F_NORMAL;
  752.     }
  753.     
  754.     /* paint background */
  755.     if (selected) {
  756.     XSetForeground(dpy, scr->select_menu_gc, scr->select_pixel);
  757.     XFillRectangle(dpy, win, scr->select_menu_gc, 1, y+1, w-2, h-3);
  758.     if (scr->menu_item_texture->any.type == WTEX_SOLID)
  759.         drawFrame(scr, win, y, w, h, type);
  760.     } else { 
  761.     if (scr->menu_item_texture->any.type == WTEX_SOLID) {
  762.         XClearArea(dpy, win, 0, y + 1, w - 1, h - 3, False);
  763.         /* draw the frame */
  764.         drawFrame(scr, win, y, w, h, type);
  765.     } else {
  766.         XClearArea(dpy, win, 0, y, w, h, False);
  767.     }
  768.     }
  769.  
  770.     if (selected) {
  771.     textGC = scr->select_menu_gc;
  772.     if (entry->flags.enabled) 
  773.         XSetForeground(dpy, textGC, scr->select_text_pixel);
  774.     else
  775.         XSetForeground(dpy, textGC, scr->dtext_pixel);
  776.     } else if (!entry->flags.enabled) {
  777.     textGC = scr->disabled_menu_entry_gc;
  778.     } else { 
  779.     textGC = scr->menu_entry_gc;
  780.     }
  781.     /* draw text */    
  782.     x = 5;
  783.     if (entry->flags.indicator)
  784.     x += MENU_INDICATOR_SPACE + 2;
  785.  
  786.     WMDrawString(scr->wmscreen, win, textGC, scr->menu_entry_font, 
  787.          x, 3 + y + wPreferences.menu_text_clearance, entry->text, strlen(entry->text));
  788.  
  789.     if (entry->cascade>=0) {
  790.     /* draw the cascade indicator */
  791.     XDrawLine(dpy,win,dim, w-11, y+6, w-6, y+h/2-1);
  792.     XDrawLine(dpy,win,light, w-11, y+h-8, w-6, y+h/2-1);
  793.     XDrawLine(dpy,win,dark, w-12, y+6, w-12, y+h-8);
  794.     }
  795.  
  796.     /* draw indicator */
  797.     if (entry->flags.indicator && entry->flags.indicator_on) {
  798.     int iw, ih;
  799.     WPixmap *indicator;
  800.  
  801.     
  802.     switch (entry->flags.indicator_type) {
  803.      case MI_CHECK:
  804.         indicator = scr->menu_check_indicator;
  805.         break;
  806.      case MI_MINIWINDOW:
  807.         indicator = scr->menu_mini_indicator;
  808.         break;
  809.      case MI_HIDDEN:
  810.         indicator = scr->menu_hide_indicator;
  811.         break;
  812.      case MI_SHADED:
  813.         indicator = scr->menu_shade_indicator;
  814.         break;
  815.      case MI_DIAMOND:
  816.      default:
  817.         indicator = scr->menu_radio_indicator;
  818.         break;
  819.     }
  820.     
  821.     iw = indicator->width;
  822.     ih = indicator->height;
  823.     XSetClipMask(dpy, scr->copy_gc, indicator->mask);
  824.     XSetClipOrigin(dpy, scr->copy_gc, 5, y+(h-ih)/2);
  825.     if (selected)
  826.         XSetForeground(dpy, scr->copy_gc, scr->black_pixel);
  827.     else
  828.         XSetForeground(dpy, scr->copy_gc, scr->mtext_pixel);
  829.     XFillRectangle(dpy, win, scr->copy_gc, 5, y+(h-ih)/2, iw, ih);
  830.     /*
  831.     XCopyArea(dpy, indicator->image, win, scr->copy_gc, 0, 0,
  832.           iw, ih, 5, y+(h-ih)/2);
  833.      */
  834.     XSetClipOrigin(dpy, scr->copy_gc, 0, 0);
  835.     }
  836.  
  837.     /* draw right text */
  838.     
  839.     if (entry->rtext && entry->cascade<0) {
  840.     tw = WMWidthOfString(scr->menu_entry_font, entry->rtext,
  841.                  strlen(entry->rtext));
  842.  
  843.     WMDrawString(scr->wmscreen, win, textGC, scr->menu_entry_font, w-6-tw, 
  844.              y + 3 + wPreferences.menu_text_clearance, entry->rtext, strlen(entry->rtext));
  845.     }
  846. }
  847.  
  848.  
  849. static void
  850. move_menus(WMenu *menu, int x, int y)
  851. {
  852.     while (menu->parent) {
  853.     menu = menu->parent;
  854.     x -= MENUW(menu);
  855.     if (!wPreferences.align_menus && menu->selected_entry>=0) {
  856.         y -= menu->selected_entry*menu->entry_height;
  857.     }
  858.     }
  859.     wMenuMove(menu, x, y, True);
  860. }
  861.  
  862. static void
  863. makeVisible(WMenu *menu)
  864. {
  865.     WScreen *scr = menu->frame->screen_ptr;
  866.     int x1, y1, x2, y2, new_x, new_y, move;
  867.     
  868.     if (menu->entry_no<0) return;
  869.     
  870.     x1 = menu->frame_x;
  871.     y1 = menu->frame_y+menu->frame->top_width
  872.     + menu->selected_entry*menu->entry_height;
  873.     x2 = x1 + MENUW(menu);
  874.     y2 = y1 + menu->entry_height;
  875.     
  876.     new_x = x1;
  877.     new_y = y1;
  878.     move = 0;
  879.  
  880.     if (x1 < 0) {
  881.     new_x = 0;
  882.     move = 1;
  883.     } else if (x2 >= scr->scr_width) {
  884.     new_x = scr->scr_width - MENUW(menu) - 1;
  885.     move = 1;
  886.     }
  887.  
  888.     if (y1 < 0) {
  889.     new_y = 0;
  890.     move = 1;
  891.     } else if (y2 >= scr->scr_height) {
  892.     new_y = scr->scr_height - menu->entry_height - 1;
  893.     move = 1;
  894.     }
  895.  
  896.     new_y = new_y - menu->frame->top_width
  897.     - menu->selected_entry*menu->entry_height;
  898.     move_menus(menu, new_x, new_y);
  899. }
  900.  
  901.  
  902. static int
  903. check_key(WMenu *menu, XKeyEvent *event)
  904. {
  905.     int i, ch, s;
  906.     char buffer[32];
  907.     
  908.     if (XLookupString(event, buffer, 32, NULL, NULL)<1)
  909.     return -1;
  910.     
  911.     ch = toupper(buffer[0]);
  912.     
  913.     s = (menu->selected_entry>=0 ? menu->selected_entry+1 : 0);
  914.     
  915. again:
  916.     for (i=s; i<menu->entry_no; i++) {
  917.     if (ch==toupper(menu->entries[i]->text[0])) {
  918.         return i;
  919.     }
  920.     }
  921.     /* no match. Retry from start, if previous started from a selected entry */
  922.     if (s!=0) {
  923.     s = 0;
  924.     goto again;
  925.     }    
  926.     return -1;
  927. }
  928.  
  929.  
  930. static int
  931. keyboardMenu(WMenu *menu)
  932. {
  933.     XEvent event;
  934.     KeySym ksym=NoSymbol;
  935.     int done=0;
  936.     int index;
  937.     WMenuEntry *entry;
  938.     int old_pos_x = menu->frame_x;
  939.     int old_pos_y = menu->frame_y;
  940.     int new_x = old_pos_x, new_y = old_pos_y;
  941.     int scr_width = menu->frame->screen_ptr->scr_width;
  942.     int scr_height = menu->frame->screen_ptr->scr_height;
  943.  
  944.     if (menu->flags.editing)
  945.     return False;
  946.  
  947.  
  948.     XGrabKeyboard(dpy, menu->frame->core->window, True, GrabModeAsync,
  949.           GrabModeAsync, CurrentTime);
  950.  
  951.     if (menu->frame_y+menu->frame->top_width >= scr_height)
  952.     new_y = scr_height - menu->frame->top_width;
  953.     
  954.     if (menu->frame_x+MENUW(menu) >= scr_width)
  955.     new_x = scr_width-MENUW(menu)-1;
  956.     
  957.     move_menus(menu, new_x, new_y);
  958.  
  959.     while (!done && menu->flags.mapped) {
  960.     XAllowEvents(dpy, AsyncKeyboard, CurrentTime);
  961.     WMMaskEvent(dpy, ExposureMask|ButtonMotionMask|ButtonPressMask
  962.             |ButtonReleaseMask|KeyPressMask|KeyReleaseMask
  963.             |SubstructureNotifyMask, &event);
  964.  
  965.     switch (event.type) {
  966.      case KeyPress:
  967.         ksym = XLookupKeysym(&event.xkey, 0);
  968.         switch (ksym) {
  969.          case XK_Escape:
  970.         done = 1;
  971.         break;
  972.  
  973.          case XK_Home:
  974.          case XK_KP_Home:
  975.         selectEntry(menu, 0);
  976.         makeVisible(menu);
  977.         break;
  978.         
  979.          case XK_End:
  980.          case XK_KP_End:
  981.         selectEntry(menu, menu->entry_no-1);
  982.         makeVisible(menu);
  983.         break;
  984.         
  985.          case XK_Up:
  986. #ifdef ARROWLESS_KBD
  987.          case XK_k:
  988. #endif
  989.          case XK_KP_Up:
  990.         if (menu->selected_entry <= 0)
  991.                     selectEntry(menu, menu->entry_no-1);
  992.         else
  993.             selectEntry(menu, menu->selected_entry-1);
  994.         makeVisible(menu);
  995.         break;
  996.         
  997.          case XK_Down:
  998. #ifdef ARROWLESS_KBD
  999.          case XK_j:
  1000. #endif
  1001.          case XK_KP_Down:
  1002.         if (menu->selected_entry<0) 
  1003.                     selectEntry(menu, 0);
  1004.                 else if (menu->selected_entry == menu->entry_no-1)
  1005.                     selectEntry(menu, 0);
  1006.         else if (menu->selected_entry < menu->entry_no-1)
  1007.             selectEntry(menu, menu->selected_entry+1);
  1008.         makeVisible(menu);
  1009.         break;
  1010.         
  1011.          case XK_Right:
  1012. #ifdef ARROWLESS_KBD
  1013.          case XK_l:
  1014. #endif
  1015.          case XK_KP_Right:
  1016.         if (menu->selected_entry>=0) {
  1017.             WMenuEntry *entry;
  1018.             entry = menu->entries[menu->selected_entry];
  1019.  
  1020.             if (entry->cascade >= 0 && menu->cascades
  1021.             && menu->cascades[entry->cascade]->entry_no > 0) {
  1022.  
  1023.             XUngrabKeyboard(dpy, CurrentTime);
  1024.  
  1025.             selectEntry(menu->cascades[entry->cascade], 0);
  1026.             if (!keyboardMenu(menu->cascades[entry->cascade]))
  1027.                 done = 1;
  1028.  
  1029.             XGrabKeyboard(dpy, menu->frame->core->window, True,
  1030.                       GrabModeAsync, GrabModeAsync,
  1031.                       CurrentTime);
  1032.             }
  1033.         }
  1034.         break;
  1035.  
  1036.          case XK_Left:
  1037. #ifdef ARROWLESS_KBD
  1038.          case XK_h:
  1039. #endif
  1040.          case XK_KP_Left:
  1041.         if (menu->parent!=NULL && menu->parent->selected_entry>=0) {
  1042.             selectEntry(menu, -1);
  1043.             move_menus(menu, old_pos_x, old_pos_y);
  1044.             return True;
  1045.         }
  1046.         break;
  1047.         
  1048.          case XK_Return:
  1049.         done = 2;
  1050.         break;
  1051.         
  1052.          default:
  1053.         index = check_key(menu, &event.xkey);
  1054.         if (index>=0) {
  1055.             selectEntry(menu, index);
  1056.         }
  1057.         }
  1058.         break;
  1059.         
  1060.      default:
  1061.         if (event.type==ButtonPress)
  1062.         done = 1;
  1063.         
  1064.         WMHandleEvent(&event);
  1065.     }
  1066.     }
  1067.  
  1068.     XUngrabKeyboard(dpy, CurrentTime);
  1069.  
  1070.     if (done==2 && menu->selected_entry>=0) {
  1071.     entry = menu->entries[menu->selected_entry];
  1072.     } else {
  1073.     entry = NULL;
  1074.     }
  1075.  
  1076.     if (entry && entry->callback!=NULL && entry->flags.enabled
  1077.     && entry->cascade < 0) {
  1078. #if (MENU_BLINK_COUNT > 0)
  1079.     int sel = menu->selected_entry;
  1080.     int i;
  1081.     
  1082.     for (i=0; i<MENU_BLINK_COUNT; i++) {
  1083.         paintEntry(menu, sel, False);
  1084.         XSync(dpy, 0);
  1085.         wusleep(MENU_BLINK_DELAY);
  1086.         paintEntry(menu, sel, True);
  1087.         XSync(dpy, 0);
  1088.         wusleep(MENU_BLINK_DELAY);
  1089.     }
  1090. #endif
  1091.     selectEntry(menu, -1);
  1092.  
  1093.     if (!menu->flags.buttoned) {
  1094.         wMenuUnmap(menu);
  1095.         move_menus(menu, old_pos_x, old_pos_y);
  1096.     }
  1097.     closeCascade(menu);
  1098.      
  1099.     (*entry->callback)(menu, entry);
  1100.     } else {
  1101.     if (!menu->flags.buttoned) {
  1102.         wMenuUnmap(menu);
  1103.         move_menus(menu, old_pos_x, old_pos_y);
  1104.     }
  1105.     selectEntry(menu, -1);
  1106.     }
  1107.  
  1108.     
  1109.     /* returns True if returning from a submenu to a parent menu,
  1110.      * False if exiting from menu */
  1111.     return False;
  1112. }
  1113.  
  1114.  
  1115. void
  1116. wMenuMapAt(WMenu *menu, int x, int y, int keyboard)
  1117. {
  1118.     int scr_width = menu->frame->screen_ptr->scr_width;
  1119.     int scr_height = menu->frame->screen_ptr->scr_height;
  1120.  
  1121.     if (!menu->flags.realized) {
  1122.     menu->flags.realized=1;
  1123.     wMenuRealize(menu);
  1124.     }
  1125.     if (!menu->flags.mapped) {
  1126.         if (wPreferences.wrap_menus) {
  1127.             if (x<0) x = 0;
  1128.             if (y<0) y = 0;
  1129.             if (x+MENUW(menu) > scr_width)
  1130.                 x = scr_width - MENUW(menu);
  1131.             if (y+MENUH(menu) > scr_height)
  1132.                 y = scr_height - MENUH(menu);
  1133.         }
  1134.  
  1135.         XMoveWindow(dpy, menu->frame->core->window, x, y);
  1136.         menu->frame_x = x;
  1137.         menu->frame_y = y;
  1138.         XMapWindow(dpy, menu->frame->core->window);
  1139.         wRaiseFrame(menu->frame->core);
  1140.         menu->flags.mapped = 1;
  1141.     } else {
  1142.         selectEntry(menu, 0);
  1143.     }
  1144.     
  1145.     if (keyboard)
  1146.     keyboardMenu(menu);
  1147. }
  1148.  
  1149.  
  1150. void
  1151. wMenuMap(WMenu *menu)
  1152. {    
  1153.     if (!menu->flags.realized) {
  1154.     menu->flags.realized=1;
  1155.     wMenuRealize(menu);
  1156.     }
  1157.     if (menu->flags.app_menu && menu->parent==NULL) {
  1158.     menu->frame_x = menu->frame->screen_ptr->app_menu_x;
  1159.     menu->frame_y = menu->frame->screen_ptr->app_menu_y;
  1160.     XMoveWindow(dpy, menu->frame->core->window, menu->frame_x, menu->frame_y);
  1161.     }
  1162.     XMapWindow(dpy, menu->frame->core->window);
  1163.     wRaiseFrame(menu->frame->core);
  1164.     menu->flags.mapped = 1;
  1165. }
  1166.  
  1167.  
  1168. void
  1169. wMenuUnmap(WMenu *menu)
  1170. {
  1171.     int i;
  1172.  
  1173.     XUnmapWindow(dpy, menu->frame->core->window);
  1174.     if (menu->flags.titled && menu->flags.buttoned) {
  1175.     wFrameWindowHideButton(menu->frame, WFF_RIGHT_BUTTON);
  1176.     }
  1177.     menu->flags.buttoned = 0;
  1178.     menu->flags.mapped = 0;
  1179.     menu->flags.open_to_left = 0;
  1180.  
  1181.     for (i=0; i<menu->cascade_no; i++) {
  1182.     if (menu->cascades[i]!=NULL
  1183.         && menu->cascades[i]->flags.mapped 
  1184.         && !menu->cascades[i]->flags.buttoned) {
  1185.         
  1186.         wMenuUnmap(menu->cascades[i]);
  1187.     }
  1188.     }
  1189.     menu->selected_entry = -1;
  1190. } 
  1191.  
  1192.  
  1193.  
  1194. void 
  1195. wMenuPaint(WMenu *menu)
  1196. { 
  1197.     int i;
  1198.      
  1199.     if (!menu->flags.mapped) {
  1200.     return;
  1201.     }
  1202.  
  1203.     /* paint entries */
  1204.     for (i=0; i<menu->entry_no; i++) {
  1205.     paintEntry(menu, i, i==menu->selected_entry);
  1206.     }
  1207. }
  1208.  
  1209.  
  1210. void
  1211. wMenuSetEnabled(WMenu *menu, int index, int enable)
  1212. {
  1213.     if (index>=menu->entry_no) return;
  1214.     menu->entries[index]->flags.enabled=enable;
  1215.     paintEntry(menu, index, index==menu->selected_entry);
  1216.     paintEntry(menu->brother, index, index==menu->selected_entry);
  1217. }
  1218.  
  1219.  
  1220. /* ====================================================================== */
  1221.  
  1222.  
  1223. static void
  1224. editEntry(WMenu *menu, WMenuEntry *entry)
  1225. {
  1226.     WTextInput *text;
  1227.     XEvent event;
  1228.     WObjDescriptor *desc;
  1229.     char *t;
  1230.     int done = 0;
  1231.     Window old_focus;
  1232.     int old_revert;
  1233.     
  1234.     menu->flags.editing = 1;
  1235.  
  1236.     text = wTextCreate(menu->menu, 1, menu->entry_height * entry->order,
  1237.                menu->menu->width - 2, menu->entry_height - 1);
  1238.  
  1239.     wTextPutText(text, entry->text);
  1240.     XGetInputFocus(dpy, &old_focus, &old_revert);
  1241.     XSetInputFocus(dpy, text->core->window, RevertToNone, CurrentTime);
  1242.     
  1243.     if (XGrabKeyboard(dpy, text->core->window, True, GrabModeAsync,
  1244.               GrabModeAsync, CurrentTime)!=GrabSuccess) {
  1245.     wwarning("could not grab keyboard");
  1246.     wTextDestroy(text);
  1247.     
  1248.     wSetFocusTo(menu->frame->screen_ptr, 
  1249.             menu->frame->screen_ptr->focused_window);
  1250.     return;
  1251.     }
  1252.  
  1253.  
  1254.     while (!done && !text->done) {
  1255.     XSync(dpy, 0);
  1256.     XAllowEvents(dpy, AsyncKeyboard|AsyncPointer, CurrentTime);
  1257.     XSync(dpy, 0);
  1258.     WMNextEvent(dpy, &event);
  1259.  
  1260.     if (XFindContext(dpy, event.xany.window, wWinContext, 
  1261.              (XPointer *)&desc)==XCNOENT)
  1262.         desc = NULL;
  1263.     
  1264.     if ((desc != NULL) && (desc->handle_anything != NULL)) {
  1265.  
  1266.         (*desc->handle_anything)(desc, &event);
  1267.  
  1268.     } else {        
  1269.         switch (event.type) {
  1270.          case ButtonPress:
  1271.         XAllowEvents(dpy, ReplayPointer, CurrentTime);
  1272.         done = 1;
  1273.  
  1274.          default:
  1275.         WMHandleEvent(&event);
  1276.         break;
  1277.         }
  1278.     }
  1279.     }
  1280.  
  1281.     XSetInputFocus(dpy, old_focus, old_revert, CurrentTime);
  1282.  
  1283.     wSetFocusTo(menu->frame->screen_ptr, 
  1284.         menu->frame->screen_ptr->focused_window);
  1285.  
  1286.  
  1287.     t = wTextGetText(text);
  1288.     /* if !t, the user has canceled editing */
  1289.     if (t) {
  1290.     if (entry->text)
  1291.         free(entry->text);
  1292.     entry->text = wstrdup(t);
  1293.     
  1294.     menu->flags.realized = 0;
  1295.     }
  1296.     wTextDestroy(text);
  1297.     
  1298.     XUngrabKeyboard(dpy, CurrentTime);
  1299.     
  1300.     if (t && menu->on_edit)
  1301.     (*menu->on_edit)(menu, entry);
  1302.     
  1303.     menu->flags.editing = 0;
  1304.  
  1305.     if (!menu->flags.realized)
  1306.     wMenuRealize(menu);
  1307. }
  1308.  
  1309.  
  1310. static void
  1311. selectEntry(WMenu *menu, int entry_no)
  1312. {
  1313.     WMenuEntry *entry;
  1314.     WMenu *submenu;
  1315.     int old_entry;
  1316.  
  1317.     if (menu->entries==NULL)
  1318.     return;
  1319.     
  1320.     if (entry_no >= menu->entry_no)
  1321.     return;
  1322.  
  1323.     old_entry = menu->selected_entry;
  1324.     menu->selected_entry = entry_no;
  1325.  
  1326.     if (old_entry!=entry_no) {
  1327.     
  1328.     /* unselect previous entry */
  1329.     if (old_entry>=0) {
  1330.         paintEntry(menu, old_entry, False);
  1331.         entry = menu->entries[old_entry];
  1332.         
  1333.         /* unmap cascade */
  1334.         if (entry->cascade>=0 && menu->cascades) {
  1335.         if (!menu->cascades[entry->cascade]->flags.buttoned) {
  1336.             wMenuUnmap(menu->cascades[entry->cascade]);
  1337.         }
  1338.         }
  1339.     }
  1340.  
  1341.     if (entry_no<0) {
  1342.         menu->selected_entry = -1;
  1343.         return;
  1344.     }
  1345.     entry = menu->entries[entry_no];
  1346.  
  1347.     if (entry->cascade>=0 && menu->cascades && entry->flags.enabled) {
  1348.         /* Callback for when the submenu is opened.
  1349.          */
  1350.         submenu = menu->cascades[entry->cascade];
  1351.         if (submenu && submenu->flags.brother)
  1352.         submenu = submenu->brother;
  1353.  
  1354.         if (entry->callback) {
  1355.         /* Only call the callback if the submenu is not yet mapped.
  1356.          */
  1357.         if (menu->flags.brother) {
  1358.             if (!submenu || !submenu->flags.mapped)
  1359.             (*entry->callback)(menu->brother, entry);
  1360.         } else {
  1361.             if (!submenu || !submenu->flags.buttoned)
  1362.             (*entry->callback)(menu, entry);
  1363.         }
  1364.         }
  1365.  
  1366.         /* the submenu menu might have changed */
  1367.         submenu = menu->cascades[entry->cascade];
  1368.         
  1369.         /* map cascade */
  1370.         if (!submenu->flags.mapped) {
  1371.                 int x, y;
  1372.  
  1373.                 if (!submenu->flags.realized)
  1374.                     wMenuRealize(submenu);
  1375.                 if (wPreferences.wrap_menus) {
  1376.                     if (menu->flags.open_to_left)
  1377.                         submenu->flags.open_to_left = 1;
  1378.  
  1379.                     if (submenu->flags.open_to_left) {
  1380.                         x = menu->frame_x - MENUW(submenu);
  1381.                         if (x<0) {
  1382.                             x = 0;
  1383.                             submenu->flags.open_to_left = 0;
  1384.                         }
  1385.                     } else {
  1386.                         x = menu->frame_x + MENUW(menu);
  1387.  
  1388.                         if (x + MENUW(submenu)
  1389.                 >= menu->frame->screen_ptr->scr_width) {
  1390.  
  1391.                             x = menu->frame_x - MENUW(submenu);
  1392.                             submenu->flags.open_to_left = 1;
  1393.                         }
  1394.                     }
  1395.                 } else {
  1396.                     x = menu->frame_x + MENUW(menu);
  1397.         }
  1398.  
  1399.                 if (wPreferences.align_menus) {
  1400.                     y = menu->frame_y;
  1401.                 } else {
  1402.                     y = menu->frame_y + menu->entry_height*entry_no;
  1403.                     if (menu->flags.titled)
  1404.                         y += menu->frame->top_width;
  1405.                     if (menu->cascades[entry->cascade]->flags.titled)
  1406.                         y -= menu->cascades[entry->cascade]->frame->top_width;
  1407.                 }
  1408.  
  1409.                 wMenuMapAt(menu->cascades[entry->cascade], x, y, False);
  1410.                 menu->cascades[entry->cascade]->parent = menu;
  1411.             } else {
  1412.                 return;
  1413.             }
  1414.         }
  1415.         paintEntry(menu, entry_no, True);
  1416.     }
  1417. }
  1418.  
  1419.  
  1420. static WMenu*
  1421. findMenu(WScreen *scr, int *x_ret, int *y_ret)
  1422. {
  1423.     WMenu *menu;
  1424.     WObjDescriptor *desc;
  1425.     Window root_ret, win, junk_win;
  1426.     int x, y, wx, wy;
  1427.     unsigned int mask;
  1428.     
  1429.     XQueryPointer(dpy, scr->root_win, &root_ret, &win, &x, &y, &wx, &wy,
  1430.           &mask);
  1431.     
  1432.     if (win==None) return NULL;
  1433.     
  1434.     if (XFindContext(dpy, win, wWinContext, (XPointer *)&desc)==XCNOENT)
  1435.       return NULL;
  1436.     
  1437.     if (desc->parent_type == WCLASS_MENU) {
  1438.     menu = (WMenu*)desc->parent;
  1439.     XTranslateCoordinates(dpy, root_ret, menu->menu->window, wx, wy, 
  1440.                   x_ret, y_ret, &junk_win);
  1441.     return menu;
  1442.     }
  1443.     return NULL;
  1444. }
  1445.  
  1446.  
  1447.  
  1448.  
  1449. static void
  1450. closeCascade(WMenu *menu)
  1451. {
  1452.     WMenu *parent=menu->parent;
  1453.  
  1454.     if (menu->flags.brother 
  1455.     || (!menu->flags.buttoned 
  1456.         && (!menu->flags.app_menu||menu->parent!=NULL))) {
  1457.  
  1458.     selectEntry(menu, -1);
  1459.     XSync(dpy, 0);
  1460. #if (MENU_BLINK_DELAY > 2)
  1461.     wusleep(MENU_BLINK_DELAY/2);
  1462. #endif
  1463.     wMenuUnmap(menu);
  1464.     while (parent!=NULL
  1465.            && (parent->parent!=NULL || !parent->flags.app_menu
  1466.            || parent->flags.brother)
  1467.            && !parent->flags.buttoned) {
  1468.         selectEntry(parent, -1);
  1469.         wMenuUnmap(parent);
  1470.         parent = parent->parent;
  1471.     }
  1472.     if (parent)
  1473.       selectEntry(parent, -1);
  1474.     }
  1475. }
  1476.  
  1477.  
  1478. static void
  1479. closeBrotherCascadesOf(WMenu *menu)
  1480. {
  1481.     WMenu *tmp;
  1482.     int i;
  1483.     
  1484.     for (i=0; i<menu->cascade_no; i++) {
  1485.     if (menu->cascades[i]->flags.brother) {
  1486.         tmp = menu->cascades[i];
  1487.     } else {
  1488.         tmp = menu->cascades[i]->brother;
  1489.     }
  1490.     if (tmp->flags.mapped) {
  1491.         selectEntry(tmp->parent, -1);
  1492.         closeBrotherCascadesOf(tmp);
  1493.         break;
  1494.     }
  1495.     }
  1496. }
  1497.  
  1498.  
  1499. #define getEntryAt(menu, x, y)   ((y)<0 ? -1 : (y)/(menu->entry_height))
  1500.  
  1501.  
  1502. static WMenu*
  1503. parentMenu(WMenu *menu)
  1504. {
  1505.     WMenu *parent;
  1506.     WMenuEntry *entry;
  1507.  
  1508.     if (menu->flags.buttoned)
  1509.     return menu;
  1510.  
  1511.     while (menu->parent && menu->parent->flags.mapped) {
  1512.         parent = menu->parent;
  1513.         if (parent->selected_entry < 0)
  1514.             break;
  1515.         entry = parent->entries[parent->selected_entry];
  1516.         if (!entry->flags.enabled || entry->cascade<0 || !parent->cascades ||
  1517.             parent->cascades[entry->cascade] != menu)
  1518.             break;
  1519.         menu = parent;
  1520.         if (menu->flags.buttoned)
  1521.             break;
  1522.     }
  1523.     
  1524.     return menu;
  1525. }
  1526.  
  1527.  
  1528.  
  1529. /*
  1530.  * Will raise the passed menu, if submenu = 0
  1531.  * If submenu > 0 will also raise all mapped submenus
  1532.  * until the first buttoned one
  1533.  * If submenu < 0 will also raise all mapped parent menus
  1534.  * until the first buttoned one
  1535.  */
  1536.  
  1537. static void
  1538. raiseMenus(WMenu *menu, int submenus)
  1539. {
  1540.     WMenu *submenu;
  1541.     int i;
  1542.  
  1543.     if(!menu) return;
  1544.  
  1545.     wRaiseFrame(menu->frame->core);
  1546.  
  1547.     if (submenus>0 && menu->selected_entry>=0) {
  1548.         i = menu->entries[menu->selected_entry]->cascade;
  1549.         if (i>=0 && menu->cascades) {
  1550.             submenu = menu->cascades[i];
  1551.             if (submenu->flags.mapped && !submenu->flags.buttoned)
  1552.                 raiseMenus(submenu, submenus);
  1553.         }
  1554.     }
  1555.     if (submenus<0 && !menu->flags.buttoned &&
  1556.         menu->parent && menu->parent->flags.mapped)
  1557.         raiseMenus(menu->parent, submenus);
  1558. }
  1559.  
  1560.  
  1561. WMenu*
  1562. wMenuUnderPointer(WScreen *screen)
  1563. {
  1564.     WObjDescriptor *desc;
  1565.     Window root_ret, win;
  1566.     int dummy;
  1567.     unsigned int mask;
  1568.  
  1569.     XQueryPointer(dpy, screen->root_win, &root_ret, &win, &dummy, &dummy,
  1570.                   &dummy, &dummy, &mask);
  1571.  
  1572.     if (win==None) return NULL;
  1573.  
  1574.     if (XFindContext(dpy, win, wWinContext, (XPointer *)&desc)==XCNOENT)
  1575.         return NULL;
  1576.  
  1577.     if (desc->parent_type == WCLASS_MENU)
  1578.         return (WMenu *)desc->parent;
  1579.     return NULL;
  1580. }
  1581.  
  1582.  
  1583.  
  1584. #define MIN(a,b)  (((a) > (b)) ? (b) : (a))
  1585.  
  1586.  
  1587. static void
  1588. getPointerPosition(WScreen *scr, int *x, int *y)
  1589. {
  1590.     Window root_ret, win;
  1591.     int wx, wy;
  1592.     unsigned int mask;
  1593.  
  1594.     XQueryPointer(dpy, scr->root_win, &root_ret, &win, x, y, &wx, &wy, &mask);
  1595. }
  1596.  
  1597.  
  1598. static void
  1599. getScrollAmount(WMenu *menu, int *hamount, int *vamount)
  1600. {
  1601.     WScreen *scr = menu->menu->screen_ptr;
  1602.     int menuX1 = menu->frame_x;
  1603.     int menuY1 = menu->frame_y;
  1604.     int menuX2 = menu->frame_x + MENUW(menu);
  1605.     int menuY2 = menu->frame_y + MENUH(menu);
  1606.     int screenW = scr->scr_width;
  1607.     int screenH = scr->scr_height;
  1608.     int xroot, yroot;
  1609.     
  1610.     *hamount = 0;
  1611.     *vamount = 0;
  1612.     
  1613.     getPointerPosition(scr, &xroot, &yroot);
  1614.  
  1615. #ifdef VIRTUAL_DESKTOP
  1616.     if (wPreferences.vedge_thickness) {
  1617.         if (xroot <= wPreferences.vedge_thickness + 1 && menuX1 < wPreferences.vedge_thickness) {
  1618.             /* scroll to the right */
  1619.             *hamount = MIN(MENU_SCROLL_STEP, abs(menuX1));
  1620.  
  1621.         } else if (xroot >= screenW-2-wPreferences.vedge_thickness && menuX2 > screenW-1-wPreferences.vedge_thickness) {
  1622.             /* scroll to the left */
  1623.             *hamount = MIN(MENU_SCROLL_STEP, abs(menuX2-screenW-1));
  1624.  
  1625.             if (*hamount==0)
  1626.                 *hamount = 1;
  1627.  
  1628.             *hamount = -*hamount;
  1629.         }
  1630.     } else
  1631. #endif
  1632.  
  1633.     if (xroot <= 1 && menuX1 < 0) {
  1634.     /* scroll to the right */
  1635.     *hamount = MIN(MENU_SCROLL_STEP, abs(menuX1));
  1636.  
  1637.     } else if (xroot >= screenW-2 && menuX2 > screenW-1) {
  1638.     /* scroll to the left */
  1639.     *hamount = MIN(MENU_SCROLL_STEP, abs(menuX2-screenW-1));
  1640.     
  1641.     if (*hamount==0)
  1642.         *hamount = 1;
  1643.  
  1644.     *hamount = -*hamount;
  1645.     }
  1646.     
  1647.     if (yroot <= 1 && menuY1 < 0) {
  1648.     /* scroll down */
  1649.     *vamount = MIN(MENU_SCROLL_STEP, abs(menuY1));
  1650.         
  1651.     } else if (yroot >= screenH-2 && menuY2 > screenH-1) {
  1652.     /* scroll up */
  1653.     *vamount = MIN(MENU_SCROLL_STEP, abs(menuY2-screenH-2));
  1654.         
  1655.     *vamount = -*vamount;
  1656.     }
  1657. }
  1658.  
  1659.  
  1660. static void
  1661. dragScrollMenuCallback(void *data)
  1662. {
  1663.     WMenu *menu = (WMenu*)data;
  1664.     WScreen *scr = menu->menu->screen_ptr;
  1665.     WMenu *parent = parentMenu(menu);
  1666.     int hamount, vamount;
  1667.     int x, y;
  1668.     int newSelectedEntry;
  1669.     
  1670.     getScrollAmount(menu, &hamount, &vamount);
  1671.     
  1672.     
  1673.     if (hamount != 0 || vamount != 0) {
  1674.     wMenuMove(parent, parent->frame_x + hamount,
  1675.           parent->frame_y + vamount, True);
  1676.     if (findMenu(scr, &x, &y)) {
  1677.         newSelectedEntry = getEntryAt(menu, x, y);
  1678.         selectEntry(menu, newSelectedEntry);
  1679.     } else {
  1680.         /* Pointer fell outside of menu. If the selected entry is
  1681.          * not a submenu, unselect it */
  1682.         if (menu->selected_entry >= 0 
  1683.         && menu->entries[menu->selected_entry]->cascade<0)
  1684.         selectEntry(menu, -1);
  1685.         newSelectedEntry = 0;
  1686.     }
  1687.     
  1688.     /* paranoid check */
  1689.     if (newSelectedEntry >= 0) {
  1690.         /* keep scrolling */
  1691.         menu->timer = WMAddTimerHandler(MENU_SCROLL_DELAY, 
  1692.                         dragScrollMenuCallback, menu);
  1693.     } else {
  1694.         menu->timer = NULL;
  1695.     }
  1696.     } else {
  1697.     /* don't need to scroll anymore */
  1698.     menu->timer = NULL;
  1699.     if (findMenu(scr, &x, &y)) {
  1700.         newSelectedEntry = getEntryAt(menu, x, y);
  1701.         selectEntry(menu, newSelectedEntry);
  1702.     }
  1703.     }
  1704. }
  1705.  
  1706.  
  1707. static void
  1708. scrollMenuCallback(void *data)
  1709. {
  1710.     WMenu *menu = (WMenu*)data;
  1711.     WMenu *parent = parentMenu(menu);
  1712.     int hamount = 0;               /* amount to scroll */
  1713.     int vamount = 0;
  1714.  
  1715.     getScrollAmount(menu, &hamount, &vamount);
  1716.     
  1717.     if (hamount != 0 || vamount != 0) {
  1718.     wMenuMove(parent, parent->frame_x + hamount,
  1719.           parent->frame_y + vamount, True);
  1720.  
  1721.     /* keep scrolling */
  1722.     menu->timer = WMAddTimerHandler(MENU_SCROLL_DELAY, 
  1723.                     scrollMenuCallback, menu);
  1724.     } else {
  1725.     /* don't need to scroll anymore */
  1726.     menu->timer = NULL;
  1727.     }
  1728. }
  1729.  
  1730.  
  1731.  
  1732. #define MENU_SCROLL_BORDER   5
  1733.  
  1734. static int
  1735. isPointNearBoder(WMenu *menu, int x, int y)
  1736. {
  1737.     int menuX1 = menu->frame_x;
  1738.     int menuY1 = menu->frame_y;
  1739.     int menuX2 = menu->frame_x + MENUW(menu);
  1740.     int menuY2 = menu->frame_y + MENUH(menu);
  1741.     int scrXe = menu->menu->screen_ptr->scr_width-1;
  1742.     int scrYe = menu->menu->screen_ptr->scr_height-1;
  1743.     int flag = 0;
  1744.     
  1745.     if (x >= menuX1 && x <= menuX2 && (y < MENU_SCROLL_BORDER
  1746.                        || y > scrYe-MENU_SCROLL_BORDER))
  1747.     flag = 1;
  1748.     else if (y >= menuY1 && y <= menuY2 && (x < MENU_SCROLL_BORDER
  1749.                         || x > scrXe-MENU_SCROLL_BORDER))
  1750.     flag = 1;
  1751.     
  1752.     return flag;
  1753. }
  1754.  
  1755.  
  1756. typedef struct _delay {
  1757.     WWindow *wwin;
  1758.     WMenu *menu;
  1759.     int ox,oy;
  1760. } _delay;
  1761.  
  1762.  
  1763. static void
  1764. _leaving(_delay *dl)
  1765. {
  1766.     wMenuMove(dl->menu, dl->ox, dl->oy, True);
  1767.     dl->menu->jump_back=NULL;
  1768.     dl->menu->menu->screen_ptr->flags.jump_back_pending = 0;
  1769.     free(dl);
  1770. }
  1771.  
  1772.  
  1773. void
  1774. wMenuScroll(WMenu *menu, XEvent *event)
  1775. {
  1776.     WMenu *smenu;
  1777.     WMenu *omenu = parentMenu(menu);
  1778.     WScreen *scr = menu->frame->screen_ptr;
  1779.     int done = 0;
  1780.     int jump_back = 0;
  1781.     int old_frame_x = omenu->frame_x;
  1782.     int old_frame_y = omenu->frame_y;
  1783.     XEvent ev;
  1784.     
  1785.     if (omenu->jump_back)
  1786.         WMDeleteTimerWithClientData(omenu->jump_back);
  1787.  
  1788.  
  1789.     if ((/*omenu->flags.buttoned &&*/ !wPreferences.wrap_menus)
  1790.         || omenu->flags.app_menu) {
  1791.         jump_back = 1;
  1792.     }
  1793.  
  1794.     if (!wPreferences.wrap_menus)
  1795.         raiseMenus(omenu, True);
  1796.     else
  1797.         raiseMenus(menu, False);
  1798.  
  1799.     if (!menu->timer)
  1800.     scrollMenuCallback(menu);    
  1801.  
  1802.     while(!done) {
  1803.         int x, y, on_border, on_x_edge, on_y_edge, on_title;
  1804.  
  1805.         WMNextEvent(dpy, &ev);
  1806.         switch (ev.type) {
  1807.      case EnterNotify:
  1808.             WMHandleEvent(&ev);
  1809.      case MotionNotify:
  1810.             x = (ev.type==MotionNotify) ? ev.xmotion.x_root : ev.xcrossing.x_root;
  1811.             y = (ev.type==MotionNotify) ? ev.xmotion.y_root : ev.xcrossing.y_root;
  1812.  
  1813.         /* on_border is != 0 if the pointer is between the menu
  1814.          * and the screen border and is close enough to the border */
  1815.         on_border = isPointNearBoder(menu, x, y);
  1816.  
  1817.             smenu = wMenuUnderPointer(scr);
  1818.                 
  1819.             if ((smenu==NULL && !on_border) || (smenu && parentMenu(smenu)!=omenu)) {
  1820.                 done = 1;
  1821.                 break;
  1822.             }
  1823.  
  1824.             on_x_edge = x <= 1 || x >= scr->scr_width - 2;
  1825.             on_y_edge = y <= 1 || y >= scr->scr_height - 2;
  1826.             on_border = on_x_edge || on_y_edge;
  1827.  
  1828.             if (!on_border && !jump_back) {
  1829.                 done = 1;
  1830.                 break;
  1831.             }
  1832.  
  1833.             if (menu->timer && (smenu!=menu || (!on_y_edge && !on_x_edge))) {
  1834.                 WMDeleteTimerHandler(menu->timer);
  1835.                 menu->timer = NULL;
  1836.             }
  1837.  
  1838.             if (smenu != NULL)
  1839.                 menu = smenu;
  1840.  
  1841.         if (!menu->timer)
  1842.         scrollMenuCallback(menu);
  1843.             break;
  1844.         case ButtonPress:
  1845.             /* True if we push on title, or drag the omenu to other position */
  1846.             on_title = ev.xbutton.x_root >= omenu->frame_x &&
  1847.                 ev.xbutton.x_root <= omenu->frame_x + MENUW(omenu) &&
  1848.                 ev.xbutton.y_root >= omenu->frame_y &&
  1849.                 ev.xbutton.y_root <= omenu->frame_y + omenu->frame->top_width;
  1850.             WMHandleEvent(&ev);
  1851.             smenu = wMenuUnderPointer(scr);
  1852.             if (smenu == NULL || (smenu && smenu->flags.buttoned && smenu != omenu))
  1853.                 done = 1;
  1854.             else if (smenu==omenu && on_title) {
  1855.                 jump_back = 0;
  1856.                 done = 1;
  1857.             }
  1858.             break;
  1859.         case KeyPress:
  1860.             done = 1;
  1861.         default:
  1862.             WMHandleEvent(&ev);
  1863.             break;
  1864.         }
  1865.     }
  1866.  
  1867.     if (menu->timer) {
  1868.         WMDeleteTimerHandler(menu->timer);
  1869.     menu->timer = NULL;
  1870.     }
  1871.  
  1872.     if (jump_back) {
  1873.         _delay *delayer;
  1874.         if (!omenu->jump_back) {
  1875.             delayer=wmalloc(sizeof(_delay));
  1876.             delayer->menu=omenu;
  1877.             delayer->ox=old_frame_x;
  1878.             delayer->oy=old_frame_y;
  1879.             omenu->jump_back=delayer;
  1880.             scr->flags.jump_back_pending = 1;
  1881.         }
  1882.         else delayer = omenu->jump_back;
  1883.         WMAddTimerHandler(MENU_JUMP_BACK_DELAY,(WMCallback*)_leaving, delayer);
  1884.     }
  1885. }
  1886.  
  1887.  
  1888.  
  1889. static void  
  1890. menuExpose(WObjDescriptor *desc, XEvent *event)
  1891. {
  1892.     wMenuPaint(desc->parent);
  1893. }
  1894.  
  1895. typedef struct {
  1896.     int *delayed_select;
  1897.     WMenu *menu;
  1898.     WMHandlerID magic;
  1899. } delay_data;
  1900.  
  1901.  
  1902. static void
  1903. delaySelection(void *data)
  1904. {
  1905.     delay_data *d = (delay_data*)data;
  1906.     int x, y, entry_no;
  1907.     WMenu *menu;
  1908.  
  1909.     d->magic = NULL;
  1910.  
  1911.     menu = findMenu(d->menu->menu->screen_ptr, &x, &y);
  1912.     if (menu && (d->menu == menu || d->delayed_select)) {
  1913.         entry_no = getEntryAt(menu, x, y);
  1914.         selectEntry(menu, entry_no);
  1915.     }
  1916.     if (d->delayed_select)
  1917.     *(d->delayed_select) = 0;
  1918. }
  1919.  
  1920.  
  1921. static void  
  1922. menuMouseDown(WObjDescriptor *desc, XEvent *event)
  1923. {
  1924.     XButtonEvent *bev = &event->xbutton;
  1925.     WMenu *menu = desc->parent;
  1926.     WMenu *smenu;
  1927.     WScreen *scr=menu->frame->screen_ptr;    
  1928.     WMenuEntry *entry=NULL;
  1929.     XEvent ev;
  1930.     int close_on_exit=0;
  1931.     int done=0;
  1932.     int delayed_select = 0;
  1933.     int entry_no;
  1934.     int x, y;
  1935.     int prevx, prevy;
  1936.     int old_frame_x = 0;
  1937.     int old_frame_y = 0;
  1938.     delay_data d_data = {NULL, NULL, NULL};
  1939.  
  1940.     if (!wPreferences.wrap_menus) {
  1941.         smenu = parentMenu(menu);
  1942.         old_frame_x = smenu->frame_x;
  1943.         old_frame_y = smenu->frame_y;
  1944.     } else if (event->xbutton.window == menu->frame->core->window) {
  1945.         /* This is true if the menu was launched with right click on root window */
  1946.         delayed_select = 1;
  1947.         d_data.delayed_select = &delayed_select;
  1948.         d_data.menu = menu;
  1949.         d_data.magic = WMAddTimerHandler(wPreferences.dblclick_time,
  1950.                                         delaySelection, &d_data);
  1951.     }
  1952.     
  1953.     if (menu->flags.inside_handler) {
  1954.     return;
  1955.     }
  1956.     menu->flags.inside_handler = 1;
  1957.  
  1958.     wRaiseFrame(menu->frame->core);
  1959.     
  1960.     close_on_exit = (bev->send_event || menu->flags.brother);
  1961.  
  1962.     smenu = findMenu(scr, &x, &y);
  1963.     if (!smenu) {
  1964.     x = -1;
  1965.     y = -1;
  1966.     } else {
  1967.     menu = smenu;
  1968.     }
  1969.  
  1970.     if (menu->flags.editing) {
  1971.     goto byebye;
  1972.     }
  1973.     entry_no = getEntryAt(menu, x, y);
  1974.     if (entry_no>=0) {
  1975.     entry = menu->entries[entry_no];
  1976.  
  1977.     if (!close_on_exit && (bev->state & ControlMask) && smenu
  1978.         && entry->flags.editable) {
  1979.         editEntry(smenu, entry);
  1980.         goto byebye;
  1981.     } else if (bev->state & ControlMask) {
  1982.         goto byebye;
  1983.     }
  1984.  
  1985.     if (entry->flags.enabled && entry->cascade>=0 && menu->cascades) {
  1986.         WMenu *submenu = menu->cascades[entry->cascade];
  1987.         /* map cascade */
  1988.             if (submenu->flags.mapped && !submenu->flags.buttoned &&
  1989.                 menu->selected_entry!=entry_no) {
  1990.         wMenuUnmap(submenu);
  1991.             }
  1992.             if (!submenu->flags.mapped && !delayed_select) {
  1993.         selectEntry(menu, entry_no);
  1994.         } else if (!submenu->flags.buttoned) {
  1995.         selectEntry(menu, -1);
  1996.         }
  1997.         
  1998.         } else if (!delayed_select) {
  1999.             selectEntry(menu, entry_no);
  2000.         }
  2001.  
  2002.         if (!wPreferences.wrap_menus && !wPreferences.scrollable_menus) {
  2003.         if (!menu->timer)
  2004.         dragScrollMenuCallback(menu);
  2005.         }
  2006.     }
  2007.     
  2008.     prevx = bev->x_root;
  2009.     prevy = bev->y_root;
  2010.     while (!done) {
  2011.     int x, y;
  2012.  
  2013.     XAllowEvents(dpy, AsyncPointer|SyncPointer, CurrentTime);
  2014.  
  2015.     WMMaskEvent(dpy, ExposureMask|ButtonMotionMask|ButtonReleaseMask
  2016.             |ButtonPressMask, &ev);
  2017.     switch (ev.type) {
  2018.      case MotionNotify:
  2019.             smenu = findMenu(scr, &x, &y);
  2020.  
  2021.         if (smenu == NULL) {
  2022.         /* moved mouse out of menu */
  2023.         
  2024.         if (!delayed_select && d_data.magic) {
  2025.             WMDeleteTimerHandler(d_data.magic);
  2026.             d_data.magic = NULL;
  2027.         }
  2028.         if (menu==NULL
  2029.             || (menu->selected_entry>=0
  2030.             && menu->entries[menu->selected_entry]->cascade>=0)) {
  2031.             prevx = ev.xmotion.x_root;
  2032.             prevy = ev.xmotion.y_root;
  2033.             
  2034.             break;
  2035.         }
  2036.         selectEntry(menu, -1);
  2037.         menu = smenu;
  2038.         prevx = ev.xmotion.x_root;
  2039.         prevy = ev.xmotion.y_root;
  2040.         break;
  2041.         } else if (menu && menu!=smenu
  2042.                && (menu->selected_entry<0
  2043.                || menu->entries[menu->selected_entry]->cascade<0)) {
  2044.         selectEntry(menu, -1);
  2045.  
  2046.         if (!delayed_select && d_data.magic) {
  2047.             WMDeleteTimerHandler(d_data.magic);
  2048.             d_data.magic = NULL;
  2049.         }
  2050.         } else {
  2051.         
  2052.         /* hysteresis for item selection */
  2053.  
  2054.         /* check if the motion was to the side, indicating that 
  2055.          * the user may want to cross to a submenu */
  2056.         if (!delayed_select && menu) {
  2057.             int dx;
  2058.             Bool moved_to_submenu;/* moved to direction of submenu */
  2059.  
  2060.             dx = abs(prevx - ev.xmotion.x_root);
  2061.  
  2062.             moved_to_submenu = False;
  2063.             if (dx > 0 /* if moved enough to the side */
  2064.             /* maybe a open submenu */
  2065.             && menu->selected_entry>=0 
  2066.             /* moving to the right direction */
  2067.             && (wPreferences.align_menus
  2068.                 || ev.xmotion.y_root >= prevy)) {
  2069.             int index;
  2070.             
  2071.             index = menu->entries[menu->selected_entry]->cascade;
  2072.             if (index>=0) {
  2073.                 if (menu->cascades[index]->frame_x>menu->frame_x) {
  2074.                 if (prevx < ev.xmotion.x_root)
  2075.                     moved_to_submenu = True;
  2076.                 } else {
  2077.                 if (prevx > ev.xmotion.x_root)
  2078.                     moved_to_submenu = True;
  2079.                 }
  2080.             }
  2081.             }
  2082.             
  2083.  
  2084.             if (menu != smenu) {
  2085.             if (d_data.magic) {
  2086.                 WMDeleteTimerHandler(d_data.magic);
  2087.             }
  2088.             d_data.magic = NULL;
  2089.             } else if (moved_to_submenu) {
  2090.             /* while we are moving, postpone the selection */
  2091.             if (d_data.magic) {
  2092.                 WMDeleteTimerHandler(d_data.magic);
  2093.             }
  2094.             d_data.delayed_select = NULL;
  2095.             d_data.menu = menu;
  2096.             d_data.magic = WMAddTimerHandler(MENU_SELECT_DELAY, 
  2097.                              delaySelection,
  2098.                              &d_data);
  2099.             prevx = ev.xmotion.x_root;
  2100.             prevy = ev.xmotion.y_root;
  2101.             break;
  2102.             } else {
  2103.             if (d_data.magic)
  2104.                 WMDeleteTimerHandler(d_data.magic);
  2105.             d_data.magic = NULL;
  2106.             }
  2107.         }
  2108.         }
  2109.         prevx = ev.xmotion.x_root;
  2110.         prevy = ev.xmotion.y_root;
  2111.         if (menu!=smenu) {
  2112.         /* pointer crossed menus */
  2113.         if (menu && menu->timer) {
  2114.             WMDeleteTimerHandler(menu->timer);
  2115.             menu->timer = NULL;
  2116.         }
  2117.         if (smenu)
  2118.             dragScrollMenuCallback(smenu);
  2119.         }
  2120.         menu = smenu;
  2121.         if (!menu->timer)
  2122.         dragScrollMenuCallback(menu);
  2123.         
  2124.             if (!delayed_select) {
  2125.                 entry_no = getEntryAt(menu, x, y);
  2126.                 if (entry_no>=0) {
  2127.                     entry = menu->entries[entry_no];
  2128.                     if (entry->flags.enabled && entry->cascade>=0 &&
  2129.                         menu->cascades) {
  2130.                         WMenu *submenu = menu->cascades[entry->cascade];
  2131.                         if (submenu->flags.mapped && !submenu->flags.buttoned
  2132.                             && menu->selected_entry!=entry_no) {
  2133.                             wMenuUnmap(submenu);
  2134.                         }
  2135.                     }
  2136.                 }
  2137.                 selectEntry(menu, entry_no);
  2138.             }
  2139.         break;
  2140.  
  2141.      case ButtonPress:
  2142.         break;
  2143.  
  2144.      case ButtonRelease:
  2145.         if (ev.xbutton.button == event->xbutton.button)
  2146.         done=1;
  2147.             break;
  2148.  
  2149.      case Expose: 
  2150.             WMHandleEvent(&ev);
  2151.             break;
  2152.      }
  2153.     }
  2154.  
  2155.     if (menu && menu->timer) {
  2156.     WMDeleteTimerHandler(menu->timer);
  2157.     menu->timer = NULL;
  2158.     }
  2159.     if (d_data.magic!=NULL)
  2160.         WMDeleteTimerHandler(d_data.magic);
  2161.     
  2162.     if (menu && menu->selected_entry>=0) {
  2163.     entry = menu->entries[menu->selected_entry];
  2164.     if (entry->callback!=NULL && entry->flags.enabled 
  2165.         && entry->cascade < 0) {
  2166.         /* blink and erase menu selection */
  2167. #if (MENU_BLINK_DELAY > 0)
  2168.         int sel = menu->selected_entry;
  2169.         int i;
  2170.  
  2171.         for (i=0; i<MENU_BLINK_COUNT; i++) {
  2172.         paintEntry(menu, sel, False);
  2173.         XSync(dpy, 0);
  2174.         wusleep(MENU_BLINK_DELAY);
  2175.         paintEntry(menu, sel, True);
  2176.         XSync(dpy, 0);
  2177.         wusleep(MENU_BLINK_DELAY);
  2178.         }
  2179. #endif
  2180.         /* unmap the menu, it's parents and call the callback */
  2181.         if (!menu->flags.buttoned && 
  2182.         (!menu->flags.app_menu||menu->parent!=NULL)) {
  2183.         closeCascade(menu);
  2184.         } else {
  2185.         selectEntry(menu, -1);
  2186.         }
  2187.         (*entry->callback)(menu, entry);
  2188.  
  2189.         /* If the user double clicks an entry, the entry will
  2190.          * be executed twice, which is not good for things like
  2191.          * the root menu. So, ignore any clicks that were generated 
  2192.          * while the entry was being executed */
  2193.         while (XCheckTypedWindowEvent(dpy, menu->menu->window, 
  2194.                       ButtonPress, &ev));
  2195.     } else if (entry->callback!=NULL && entry->cascade<0) {
  2196.         selectEntry(menu, -1);
  2197.     } else {        
  2198.         if (entry->cascade>=0 && menu->cascades
  2199.         && menu->cascades[entry->cascade]->flags.brother) {
  2200.         selectEntry(menu, -1);
  2201.         }
  2202.     }
  2203.     }
  2204.  
  2205.     if (((WMenu*)desc->parent)->flags.brother || close_on_exit || !smenu)
  2206.     closeCascade(desc->parent);
  2207.  
  2208.     /* close the cascade windows that should not remain opened */
  2209.     closeBrotherCascadesOf(desc->parent);
  2210.  
  2211.     if (!wPreferences.wrap_menus)
  2212.         wMenuMove(parentMenu(desc->parent), old_frame_x, old_frame_y, True);
  2213.  
  2214. byebye:    
  2215.     ((WMenu*)desc->parent)->flags.inside_handler = 0;
  2216. }
  2217.  
  2218.  
  2219. void
  2220. wMenuMove(WMenu *menu, int x, int y, int submenus)
  2221. {
  2222.     WMenu *submenu;
  2223.     int i;
  2224.     
  2225.     if (!menu) return;
  2226.     
  2227.     menu->frame_x = x;
  2228.     menu->frame_y = y;
  2229.     XMoveWindow(dpy, menu->frame->core->window, x, y);
  2230.       
  2231.     if (submenus>0 && menu->selected_entry>=0) {
  2232.     i = menu->entries[menu->selected_entry]->cascade;
  2233.     
  2234.     if (i>=0 && menu->cascades) {
  2235.         submenu = menu->cascades[i];
  2236.         if (submenu->flags.mapped && !submenu->flags.buttoned) {
  2237.         if (wPreferences.align_menus) {
  2238.             wMenuMove(submenu, x + MENUW(menu), y, submenus);
  2239.         } else {
  2240.             wMenuMove(submenu, x+ MENUW(menu),
  2241.                   y + submenu->entry_height*menu->selected_entry,
  2242.                   submenus);
  2243.         }
  2244.         }
  2245.     }
  2246.     }
  2247.     if (submenus<0 && menu->parent!=NULL && menu->parent->flags.mapped &&
  2248.     !menu->parent->flags.buttoned) {
  2249.     if (wPreferences.align_menus) {
  2250.         wMenuMove(menu->parent, x - MENUW(menu->parent), y, submenus);
  2251.     } else {
  2252.         wMenuMove(menu->parent, x - MENUW(menu->parent), menu->frame_y
  2253.               - menu->parent->entry_height*menu->parent->selected_entry,
  2254.               submenus);
  2255.     }          
  2256.     }
  2257. }
  2258.  
  2259.  
  2260. static void
  2261. changeMenuLevels(WMenu *menu, int lower)
  2262. {
  2263.     int i;
  2264.  
  2265.     if (!lower) {
  2266.     ChangeStackingLevel(menu->frame->core, (!menu->parent ? WMMainMenuLevel
  2267.                       : WMSubmenuLevel));
  2268.     wRaiseFrame(menu->frame->core);
  2269.     menu->flags.lowered = 0;
  2270.     } else {
  2271.     ChangeStackingLevel(menu->frame->core, WMNormalLevel);
  2272.     wLowerFrame(menu->frame->core);
  2273.     menu->flags.lowered = 1;
  2274.     }
  2275.     for (i=0; i<menu->cascade_no; i++) {
  2276.     if (menu->cascades[i]
  2277.         && !menu->cascades[i]->flags.buttoned
  2278.         && menu->cascades[i]->flags.lowered!=lower) {
  2279.         changeMenuLevels(menu->cascades[i], lower);
  2280.     }
  2281.     }
  2282. }
  2283.  
  2284.  
  2285.  
  2286. static void 
  2287. menuTitleDoubleClick(WCoreWindow *sender, void *data, XEvent *event)
  2288. {
  2289.     WMenu *menu = data;
  2290.     int lower;
  2291.     
  2292.     if (event->xbutton.state & MOD_MASK) {
  2293.     if (menu->flags.lowered) {
  2294.         lower = 0;
  2295.     } else {
  2296.         lower = 1;
  2297.     }
  2298.     changeMenuLevels(menu, lower);
  2299.     }
  2300. }
  2301.  
  2302.  
  2303. static void 
  2304. menuTitleMouseDown(WCoreWindow *sender, void *data, XEvent *event)
  2305. {
  2306.     WMenu *menu = data;
  2307.     WMenu *tmp;
  2308.     XEvent ev;
  2309.     int x=menu->frame_x, y=menu->frame_y;
  2310.     int dx=event->xbutton.x_root, dy=event->xbutton.y_root;
  2311.     int i, lower;
  2312.     Bool started;
  2313.  
  2314.     /* can't touch the menu copy */
  2315.     if (menu->flags.brother)
  2316.     return;
  2317.  
  2318.     if (event->xbutton.button != Button1 && event->xbutton.button != Button2)
  2319.       return;
  2320.  
  2321.     if (event->xbutton.state & MOD_MASK) {
  2322.     wLowerFrame(menu->frame->core);
  2323.     lower = 1;
  2324.     } else {
  2325.     wRaiseFrame(menu->frame->core);
  2326.     lower = 0;
  2327.     }
  2328.     tmp = menu;
  2329.  
  2330.     /* lower/raise all submenus */
  2331.     while (1) {
  2332.     if (tmp->selected_entry>=0 && tmp->cascades
  2333.         && tmp->entries[tmp->selected_entry]->cascade>=0) {
  2334.         tmp = tmp->cascades[tmp->entries[tmp->selected_entry]->cascade];
  2335.         if (!tmp || !tmp->flags.mapped)
  2336.           break;
  2337.         if (lower)
  2338.           wLowerFrame(tmp->frame->core);
  2339.         else
  2340.           wRaiseFrame(tmp->frame->core);
  2341.     } else {
  2342.         break;
  2343.     }
  2344.     }
  2345.  
  2346.     /* tear off the menu if it's a root menu or a cascade 
  2347.      application menu */
  2348.     if (!menu->flags.buttoned && !menu->flags.brother 
  2349.     && (!menu->flags.app_menu||menu->parent!=NULL)) {
  2350.     menu->flags.buttoned=1;
  2351.     wFrameWindowShowButton(menu->frame, WFF_RIGHT_BUTTON);
  2352.     if (menu->parent) {
  2353.         /* turn off selected menu entry in parent menu */
  2354.         selectEntry(menu->parent, -1);
  2355.  
  2356.         /* make parent map the copy in place of the original */
  2357.         for (i=0; i<menu->parent->cascade_no; i++) {
  2358.         if (menu->parent->cascades[i] == menu) {
  2359.             menu->parent->cascades[i] = menu->brother;
  2360.             break;
  2361.         }
  2362.         }
  2363.     }
  2364.     }
  2365.  
  2366.     started = False;
  2367.     while(1) {
  2368.     WMMaskEvent(dpy, ButtonMotionMask|ButtonReleaseMask|ButtonPressMask
  2369.             |ExposureMask, &ev);
  2370.     switch (ev.type) {
  2371.      case MotionNotify:
  2372.         if (started) {
  2373.         x += ev.xmotion.x_root - dx;
  2374.         y += ev.xmotion.y_root - dy;
  2375.         dx = ev.xmotion.x_root;
  2376.         dy = ev.xmotion.y_root;
  2377.         wMenuMove(menu, x, y, True);
  2378.         } else {
  2379.         if (abs(ev.xmotion.x_root - dx) > MOVE_THRESHOLD
  2380.             || abs(ev.xmotion.y_root - dy) > MOVE_THRESHOLD) {
  2381.             started = True;
  2382.             XGrabPointer(dpy, menu->frame->titlebar->window, False, 
  2383.                  ButtonMotionMask|ButtonReleaseMask
  2384.                  |ButtonPressMask,
  2385.                  GrabModeAsync, GrabModeAsync, None, 
  2386.                  wCursor[WCUR_MOVE], CurrentTime);
  2387.         }
  2388.         }
  2389.         break;
  2390.  
  2391.      case ButtonPress:
  2392.         break;
  2393.  
  2394.      case ButtonRelease:
  2395.         if (ev.xbutton.button != event->xbutton.button)
  2396.         break;
  2397.         XUngrabPointer(dpy, CurrentTime);
  2398.         return;
  2399.  
  2400.      default:
  2401.         WMHandleEvent(&ev);
  2402.         break;
  2403.     }
  2404.     }
  2405. }
  2406.  
  2407. /*
  2408.  *----------------------------------------------------------------------
  2409.  * menuCloseClick--
  2410.  *     Handles mouse click on the close button of menus. The menu is
  2411.  * closed when the button is clicked. 
  2412.  * 
  2413.  * Side effects:
  2414.  *     The closed menu is reinserted at it's parent menus
  2415.  * cascade list.
  2416.  *---------------------------------------------------------------------- 
  2417.  */
  2418. static void 
  2419. menuCloseClick(WCoreWindow *sender, void *data, XEvent *event)
  2420. {
  2421.     WMenu *menu = (WMenu*)data;
  2422.     WMenu *parent = menu->parent;
  2423.     int i;
  2424.     
  2425.     if (parent) {
  2426.     for (i=0; i<parent->cascade_no; i++) {
  2427.         /* find the entry that points to the copy */
  2428.         if (parent->cascades[i] == menu->brother) {
  2429.         /* make it point to the original */
  2430.         parent->cascades[i] = menu;
  2431.         menu->parent = parent;
  2432.         break;
  2433.         }
  2434.     }
  2435.     }
  2436.     wMenuUnmap(menu);
  2437. }
  2438.  
  2439.  
  2440. static void
  2441. saveMenuInfo(proplist_t dict, WMenu *menu, proplist_t key)
  2442. {
  2443.     proplist_t value, list;
  2444.     char buffer[256];
  2445.  
  2446.     sprintf(buffer, "%i,%i", menu->frame_x, menu->frame_y);
  2447.     value = PLMakeString(buffer);
  2448.     list = PLMakeArrayFromElements(value, NULL);
  2449.     if (menu->flags.lowered)
  2450.     PLAppendArrayElement(list, PLMakeString("lowered"));
  2451.     PLInsertDictionaryEntry(dict, key, list);
  2452.     PLRelease(value);
  2453.     PLRelease(list);
  2454. }
  2455.  
  2456.  
  2457. void
  2458. wMenuSaveState(WScreen *scr)
  2459. {
  2460.     proplist_t menus, key;
  2461.     int save_menus = 0;
  2462.  
  2463.     menus = PLMakeDictionaryFromEntries(NULL, NULL, NULL);
  2464.  
  2465. #ifndef LITE
  2466.     if (scr->switch_menu && scr->switch_menu->flags.buttoned) {
  2467.     key = PLMakeString("SwitchMenu");
  2468.     saveMenuInfo(menus, scr->switch_menu, key);
  2469.     PLRelease(key);
  2470.         save_menus = 1;
  2471.     }
  2472.  
  2473.     if (saveMenuRecurs(menus, scr, scr->root_menu))
  2474.     save_menus = 1;
  2475.  
  2476. #endif /* !LITE */
  2477.     if (scr->workspace_menu && scr->workspace_menu->flags.buttoned) {
  2478.         key = PLMakeString("WorkspaceMenu");
  2479.     saveMenuInfo(menus, scr->workspace_menu, key);
  2480.         PLRelease(key);
  2481.         save_menus = 1;
  2482.     }
  2483.     
  2484.     if (save_menus) {
  2485.         key = PLMakeString("Menus");
  2486.         PLInsertDictionaryEntry(scr->session_state, key, menus);
  2487.         PLRelease(key);
  2488.     }
  2489.     PLRelease(menus);
  2490. }
  2491.  
  2492.  
  2493. #ifndef LITE
  2494.  
  2495. static Bool
  2496. getMenuPath(WMenu *menu, char *buffer, int bufSize)
  2497. {
  2498.     Bool ok = True;
  2499.     int len = 0;
  2500.  
  2501.     if (!menu->flags.titled || !menu->frame->title[0])
  2502.     return False;
  2503.  
  2504.     len = strlen(menu->frame->title);
  2505.     if (len >= bufSize)
  2506.     return False;
  2507.  
  2508.     if (menu->parent) {
  2509.     ok = getMenuPath(menu->parent, buffer, bufSize - len - 1);
  2510.     if (!ok)
  2511.         return False;
  2512.     }
  2513.  
  2514.     strcat(buffer, "\\");
  2515.     strcat(buffer, menu->frame->title);
  2516.  
  2517.     return True;
  2518. }
  2519.  
  2520.  
  2521. static Bool
  2522. saveMenuRecurs(proplist_t menus, WScreen *scr, WMenu *menu)
  2523. {
  2524.     proplist_t key;
  2525.     int save_menus = 0, i;
  2526.     char buffer[512];
  2527.     Bool ok = True;
  2528.  
  2529.     
  2530.     if (menu->flags.brother)
  2531.     menu = menu->brother;
  2532.  
  2533.     if (menu->flags.buttoned && menu != scr->switch_menu) {
  2534.  
  2535.     buffer[0] = '\0';
  2536.     ok = getMenuPath(menu, buffer, 510);
  2537.  
  2538.     if (ok) {
  2539.         key = PLMakeString(buffer);
  2540.         saveMenuInfo(menus, menu, key);
  2541.         PLRelease(key);        
  2542.         save_menus = 1;
  2543.     }
  2544.     }
  2545.  
  2546.     if (ok) {
  2547.     for (i = 0; i < menu->cascade_no; i++) {
  2548.         if (saveMenuRecurs(menus, scr, menu->cascades[i]))
  2549.         save_menus = 1;
  2550.     }
  2551.     }
  2552.     return save_menus;
  2553. }
  2554. #endif /* !LITE */
  2555.  
  2556.  
  2557. #define COMPLAIN(key) wwarning(_("bad value in menus state info:%s"), key)
  2558.  
  2559.  
  2560. static Bool
  2561. getMenuInfo(proplist_t info, int *x, int *y, Bool *lowered)
  2562. {
  2563.     proplist_t pos;
  2564.     
  2565.     *lowered = False;
  2566.     
  2567.     if (PLIsArray(info)) {
  2568.     proplist_t flags;
  2569.     pos = PLGetArrayElement(info, 0);
  2570.     flags = PLGetArrayElement(info, 1);
  2571.     if (flags != NULL && PLIsString(flags) && PLGetString(flags) != NULL
  2572.         && strcmp(PLGetString(flags), "lowered") == 0) {
  2573.         *lowered = True;
  2574.     }
  2575.     } else {
  2576.     pos = info;
  2577.     }
  2578.  
  2579.     if (pos != NULL && PLIsString(pos)) {
  2580.     if (sscanf(PLGetString(pos), "%i,%i", x, y)!=2)
  2581.         COMPLAIN("Position");
  2582.     } else {
  2583.     COMPLAIN("(position, flags...)");
  2584.     return False;
  2585.     }
  2586.  
  2587.     return True;
  2588. }
  2589.  
  2590.  
  2591. static int
  2592. restoreMenu(WScreen *scr, proplist_t menu, int which)
  2593. {
  2594.     int x, y;
  2595.     Bool lowered = False;
  2596.     WMenu *pmenu = NULL;
  2597.  
  2598.     if (!menu)
  2599.     return False;
  2600.     
  2601.     if (!getMenuInfo(menu, &x, &y, &lowered))
  2602.     return False;
  2603.  
  2604.  
  2605. #ifndef LITE
  2606.     if (which & WSS_SWITCHMENU) {
  2607.         OpenSwitchMenu(scr, x, y, False);
  2608.         pmenu = scr->switch_menu;
  2609.     }
  2610. #endif /* !LITE */
  2611.  
  2612.     if (pmenu) {
  2613.         int width = MENUW(pmenu);
  2614.         int height = MENUH(pmenu);
  2615.         
  2616.     if (lowered) {
  2617.         changeMenuLevels(pmenu, True);
  2618.     }
  2619.     
  2620.         x = (x < -width) ? 0 : x;
  2621.         x = (x > scr->scr_width) ? scr->scr_width - width : x;
  2622.         y = (y < 0) ? 0 : y;
  2623.         y = (y > scr->scr_height) ? scr->scr_height - height : y;
  2624.         wMenuMove(pmenu, x, y, True);
  2625.         pmenu->flags.buttoned = 1;
  2626.         wFrameWindowShowButton(pmenu->frame, WFF_RIGHT_BUTTON);
  2627.         return True;
  2628.     }
  2629.     return False;
  2630. }
  2631.  
  2632.  
  2633. #ifndef LITE
  2634. static int
  2635. restoreMenuRecurs(WScreen *scr, proplist_t menus, WMenu *menu, char *path)
  2636. {
  2637.     proplist_t key, entry;
  2638.     char buffer[512];
  2639.     int i, x, y, res;
  2640.     Bool lowered;
  2641.  
  2642.     if (strlen(path) + strlen(menu->frame->title) > 510)
  2643.     return False;
  2644.  
  2645.     sprintf(buffer, "%s\\%s", path, menu->frame->title);
  2646.     key = PLMakeString(buffer);
  2647.     entry = PLGetDictionaryEntry(menus, key);
  2648.     res = False;
  2649.  
  2650.     if (entry && getMenuInfo(entry, &x, &y, &lowered)) {
  2651.  
  2652.     if (!menu->flags.mapped) {
  2653.         int width = MENUW(menu);
  2654.         int height = MENUH(menu);
  2655.  
  2656.         wMenuMapAt(menu, x, y, False);
  2657.  
  2658.         if (menu->parent) {
  2659.         /* make parent map the copy in place of the original */
  2660.         for (i=0; i<menu->parent->cascade_no; i++) {
  2661.             if (menu->parent->cascades[i] == menu) {
  2662.             menu->parent->cascades[i] = menu->brother;
  2663.             break;
  2664.             }
  2665.         }
  2666.         }
  2667.         if (lowered) {
  2668.         changeMenuLevels(menu, True);
  2669.         }
  2670.         x = (x < -width) ? 0 : x;
  2671.         x = (x > scr->scr_width) ? scr->scr_width - width : x;
  2672.         y = (y < 0) ? 0 : y;
  2673.         y = (y > scr->scr_height) ? scr->scr_height - height : y;
  2674.         wMenuMove(menu, x, y, True);
  2675.         menu->flags.buttoned = 1;
  2676.         wFrameWindowShowButton(menu->frame, WFF_RIGHT_BUTTON);
  2677.         res = True;
  2678.     }
  2679.     }
  2680.     
  2681.     PLRelease(key);
  2682.  
  2683.     for (i=0; i<menu->cascade_no; i++) {
  2684.     if (restoreMenuRecurs(scr, menus, menu->cascades[i], buffer) != False)
  2685.         res = True;
  2686.     }
  2687.  
  2688.     return res;
  2689. }
  2690. #endif /* !LITE */
  2691.  
  2692.  
  2693. void
  2694. wMenuRestoreState(WScreen *scr)
  2695. {
  2696.     proplist_t menus, menu, key, skey;
  2697.  
  2698.     key = PLMakeString("Menus");
  2699.     menus = PLGetDictionaryEntry(scr->session_state, key);
  2700.     PLRelease(key);
  2701.  
  2702.     if (!menus)
  2703.         return;
  2704.  
  2705.     /* restore menus */
  2706.  
  2707.     skey = PLMakeString("SwitchMenu");
  2708.     menu = PLGetDictionaryEntry(menus, skey);
  2709.     PLRelease(skey);
  2710.     restoreMenu(scr, menu, WSS_SWITCHMENU);
  2711.  
  2712. #ifndef LITE
  2713.     if (!scr->root_menu) {
  2714.         OpenRootMenu(scr, scr->scr_width*2, 0, False);
  2715.         wMenuUnmap(scr->root_menu);
  2716.     }
  2717.     restoreMenuRecurs(scr, menus, scr->root_menu, "");
  2718. #endif /* !LITE */
  2719.  
  2720.     PLRelease(skey);
  2721. }
  2722.  
  2723.  
  2724. void
  2725. OpenWorkspaceMenu(WScreen *scr, int x, int y)
  2726. {
  2727.     WMenu *menu, *parent;
  2728.     WMenuEntry *entry;
  2729.  
  2730. #ifndef LITE
  2731.     if (!scr->root_menu) {
  2732.         OpenRootMenu(scr, scr->scr_width*2, 0, False);
  2733.         wMenuUnmap(scr->root_menu);
  2734.     }
  2735. #endif
  2736.     menu = scr->workspace_menu;
  2737.     if (menu) {
  2738.         if (menu->flags.mapped) {
  2739.             if (!menu->flags.buttoned) {
  2740.                 wMenuUnmap(menu);
  2741.                 parent = menu->parent;
  2742.                 if (parent && parent->selected_entry >= 0) {
  2743.                     entry = parent->entries[parent->selected_entry];
  2744.                     if (parent->cascades[entry->cascade] == menu) {
  2745.                         selectEntry(parent, -1);
  2746.                         wMenuMapAt(menu, x, y, False);
  2747.                     }
  2748.                 }
  2749.             } else {
  2750.                 wRaiseFrame(menu->frame->core);
  2751.         wMenuMapCopyAt(menu, x, y);
  2752.             }
  2753.         } else {
  2754.             wMenuMapAt(menu, x, y, False);
  2755.         }
  2756.     }
  2757. }
  2758.  
  2759.  
  2760.